Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
04be1c06c7 | ||
|
|
f907c0ed37 |
No files matched your search
@@ -50,6 +50,18 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
|
||||
Sessions recorded before, and one recovered after a crash, read N/A. Schema 0016 adds fifteen `sessions.display_*`
|
||||
columns, and `sessions.swap_effect` — a column with no writer since the first schema — is now filled.
|
||||
|
||||
- **Run the capture agent as administrator — your choice, off by default** (owner request, beta.10). Settings ▸ Capture
|
||||
agent ▸ *Run the agent as administrator* shows what it adds (measuring a game that itself runs as administrator; the CPU
|
||||
temperature where PawnIO is installed), what it does not change (a game with anti-cheat is still refused; a Vulkan game
|
||||
run as administrator is still not measured) and the risk of a per-user, unsigned install, before it turns on. Then
|
||||
**Windows asks every time the agent starts** — also at logon, when its prompt may wait on the taskbar; there is no
|
||||
silent way. Answer No and the agent runs with your standard rights and says so; answer with another administrator
|
||||
account and that agent refuses to run, because its data would not be yours. **Games you start from FrameLedger always
|
||||
run with your standard rights**, and nothing FrameLedger does enables a privilege (a CI test on an elevated runner and a
|
||||
source check hold both). While the prompt waits, the status pill says so. With the option off, an App started as
|
||||
administrator no longer makes the agent an administrator's too. Updating now also waits for an administrator agent's
|
||||
process to let go of its files.
|
||||
|
||||
### Changed
|
||||
|
||||
- **Groundwork for the display mode (beta.10): the injected component reports how the game presents** — whether its swap
|
||||
|
||||
@@ -142,3 +142,17 @@ covers\*.jpg
|
||||
- **ADR-7 (2026-07, core change):** **Capture moves to in-process graphics-API hooking**, C++20 DLL + MinHook, with a Vulkan implicit layer for Vulkan. Rationale: passive detection of DLSS/upscaling/frame-generation/RT state showed large errors against real games; those states are only knowable at the API boundary. Trade-offs accepted: anti-cheat exposure (mitigated by the hard guard in `19_SAFETY`, offline titles only), crash risk in the host process (mitigated by SEH guards + fault policy + auto-disable), a second toolchain in the build, and per-API maintenance as vendors change SDKs. Scope limited to titles the user explicitly opts in.
|
||||
- **ADR-8:** **No evasion, ever** (`19_SAFETY` §What we will never build). This is an architectural constraint, not a preference — it defines what "correct" means for this codebase.
|
||||
- **ADR-9:** Elevation demoted from required to optional; the Agent runs as a standard user by default.
|
||||
**Chosen, not inherited, since beta.10 (owner decision D34, 2026-09-27):** Settings ▸ Capture agent ▸ *Run the agent as
|
||||
administrator* (`capture.run_elevated`, off by default, a versioned disclosure — `agent-admin-dialog/1` — before it turns
|
||||
on). With it on, **Windows is asked every time the Agent starts** — a UAC prompt owned by the App's window when the App
|
||||
starts it, flashing on the taskbar when the logon task does — and there is no silent path: no "highest privileges" task,
|
||||
no service. The elevated Agent is started for one user (`--serve --for-user <SID>`) and refuses to run as another
|
||||
account (exit 11: a standard user answered with an administrator's password, and that account's `%LOCALAPPDATA%` is not
|
||||
this user's ledger); a declined prompt leaves a standard user's Agent that says so (`--elevation declined`,
|
||||
`HelloAck.ElevationOutcome`). With it off, an App started as administrator starts the Agent with the desktop shell's
|
||||
token. **A game an elevated Agent starts gets the shell's token too** (`Infrastructure.Startup.UnelevatedProcess`) —
|
||||
`LaunchGame` reaches the Agent over a pipe any process of the user may open, so an elevated launch would be a silent
|
||||
elevation — and nothing enables a privilege (`TokenPrivileges` reads them; `tools/chokepoint-check.ps1` forbids the
|
||||
enablers under `src/`). It buys what it always did: attaching to a game that runs as administrator, and the CPU
|
||||
temperature with PawnIO. It does not open a process an anti-cheat driver protects (D21), and a Vulkan game that runs as
|
||||
administrator stays unmeasured — the Khronos loader ignores the HKCU implicit layers for an elevated process.
|
||||
@@ -75,6 +75,10 @@ Requirement IDs (`FR-x`, `NFR-x`) are referenced by other docs, commits, and tes
|
||||
- FR-9.3 Chart PNG.
|
||||
|
||||
### FR-10 Settings
|
||||
|
||||
> **beta.10 (D34):** "Agent elevation (optional — explains what it unlocks)" is the admin mode — *Run the agent as
|
||||
> administrator*, off by default, a disclosure before it turns on, Windows' prompt at every Agent start (`01_ARCHITECTURE`
|
||||
> ADR-9, `08_UI` §Settings).
|
||||
Language (en/vi/ja), theme, start with Windows, minimize to tray, background capture, **global hooking kill switch**, min session length, telemetry interval, retention, Agent elevation (optional — explains what it unlocks), Vulkan layer registration state, update channel, online metadata opt-in, reopen legal documents.
|
||||
|
||||
### FR-11 Legal Gate
|
||||
|
||||
@@ -175,6 +175,13 @@ which makes the notification more important than it was, not less.
|
||||
|
||||
**Launch mode (preferred).** User starts the game from FrameLedger (or FrameLedger is set as the launch wrapper): `CreateProcess(CREATE_SUSPENDED)` → guard → inject → `ResumeThread`. Catches swapchain creation and upscaler init, which attach mode can miss entirely — a game that creates its DLSS feature during startup will otherwise report `upscaler = unknown` for the whole session.
|
||||
|
||||
> **An elevated Agent starts the game as a standard user (beta.10, the admin mode, D34).** `ProcessLauncher` checks its
|
||||
> own token: elevated, it starts the game with the desktop shell's token (`Infrastructure.Startup.UnelevatedProcess` —
|
||||
> `GetShellWindow`'s process, its token duplicated, `CreateProcessWithTokenW`, the same explicit environment the kill
|
||||
> switch decides), pins it from the start's own handle, and never falls back to its own token: with no shell the launch
|
||||
> fails with `Launch_Error_1400`. `LaunchGame` is a pipe command any process of the user can send; an elevated launch would
|
||||
> be an elevation without a prompt.
|
||||
|
||||
> **Built 2026-09-06 (P1 item 2) as "inject late", which is the only shape §S1 left possible, and the
|
||||
> sentence above is kept as the intent it does not quite describe.** A `CREATE_SUSPENDED` target has
|
||||
> loaded nothing and the module scan *fails* against it (`ERROR_PARTIAL_COPY`, §S1 measured), so the guard
|
||||
|
||||
@@ -392,6 +392,7 @@ switch's rule); integers are invariant-culture within an inclusive range; choice
|
||||
| `capture.background` | bool | `1` | | Agent |
|
||||
| `hooking.kill_switch` | bool | `0` | | Agent (FR-2.4, since P2 PR-F) |
|
||||
| `hooking.usermode_ac_exceptions` | bool | `0` | | Agent, at every session start and command (FR-2.8, D33, 2026-09-26): off suspends every user-mode exception without deleting any; on, the user still grants each eligible game |
|
||||
| `capture.run_elevated` | bool | `0` | | The App when it starts the Agent, and an Agent the logon task started — both BEFORE the Agent exists, through `Infrastructure.Startup.RunElevatedSetting` (one row, `PRAGMA query_only`, no version gate, anything but `1` is off) (D34, beta.10): on, Windows is asked for administrator rights at every Agent start (`01_ARCHITECTURE` ADR-9) |
|
||||
| `capture.min_session_s` | int | `30` | 5–600 | Agent, per session (FR-3.6) |
|
||||
| `telemetry.interval_ms` | int | `1000` | 500–2000 | Agent, per session (FR-3.5) |
|
||||
| `retention.raw_sessions_per_game` | int | `20` | 0–10000; **0 = unlimited** | Agent, per session (§Retention) |
|
||||
|
||||
+14
-1
@@ -386,7 +386,7 @@ Unchanged in spirit from v1, bumped to `v2` for the new message set.
|
||||
|
||||
| Type | Dir | Payload / notes |
|
||||
|---|---|---|
|
||||
| `Hello` | UI→A | `{ appVersion, protocol: 2 }` → `HelloAck { agentVersion, protocol, pid, elevated, overlayBuildId, vulkanLayerRegistered, telemetrySource /* composite, e.g. l1+lhm+nvapi */, cpuTempAvailable, disclosureVersion /* P3 PR-4, D14: the FR-2.1 text this Agent stamps against */, exceptionDisclosureVersion /* D33, 2026-09-26: the user-mode exception's disclosure this Agent grants against */, ~~etwAvailable~~ }` — `etwAvailable` struck 2026-09-13 with the tier it described (2026-08-28); `pid` added. `vulkanLayerRegistered` is **false by construction** today (the layer is per-launch, never registered) and `cpuTempAvailable` false unelevated; `telemetrySource` is the composite stood up once on the first `Hello` |
|
||||
| `Hello` | UI→A | `{ appVersion, protocol: 2 }` → `HelloAck { agentVersion, protocol, pid, elevated, overlayBuildId, vulkanLayerRegistered, telemetrySource /* composite, e.g. l1+lhm+nvapi */, cpuTempAvailable, disclosureVersion /* P3 PR-4, D14: the FR-2.1 text this Agent stamps against */, exceptionDisclosureVersion /* D33, 2026-09-26: the user-mode exception's disclosure this Agent grants against */, elevationOutcome /* beta.10, D34: the admin mode's answer at this start — granted, declined, other-account, failed — or null when nobody asked */, ~~etwAvailable~~ }` — `etwAvailable` struck 2026-09-13 with the tier it described (2026-08-28); `pid` added. `vulkanLayerRegistered` is **false by construction** today (the layer is per-launch, never registered) and `cpuTempAvailable` false unelevated; `telemetrySource` is the composite stood up once on the first `Hello` |
|
||||
| `GetStatus` | UI→A | → `StatusAck { state, activeSession?, tier? }` — and `activeSessions[]`, one `{ sessionGuid, gameId, gameName?, pid, tier, startedAt, hold? }` per running session. **`hold` added 2026-09-23, optional:** present on a session held unhooked (Tier 2), with the same words `SessionStarted.hold` carries; a session listed at tier 2 WITHOUT a `hold` has not attached yet — it is starting, not held. The App reads this list on every (re)connect (§Client behavior) |
|
||||
| `SetWatchlist` | UI→A | `{ entries: [{ gameId?, exePath }] }` — ~~full replace~~ **ensure, never remove** (built 2026-09-13, PR-1b): each entry's path is normalised by the Agent, its row ensured with hooking OFF when new, and the ack is `WatchlistAck { games: [{ gameId, exePath, name }], unreadable: [exePath] }`; `gameId` in a request is a hint and never trusted over the path. UI re-sends on connect. **Carries no hooking state** (see §The pipe is not a trust boundary). *Since the App writes `games` rows itself under `06_DATA_MODEL` §Writer ownership (HANDOFF §P3 D15), this is the pipe's way of adding a row, not the only one; the watcher reads the table at 1 Hz either way.* |
|
||||
| `LaunchGame` | UI→A | `{ gameId, arguments? }` → ~~suspended-launch~~ launch mode as built ("inject late", `04_CAPTURE` §Launch mode) → `LaunchAck { gameId, accepted, outcome, sessionGuid? }` — `outcome` is `Accepted` · `UnknownGame` · `SessionRunning` (one per game at a time) · `Unavailable` · `RecordingOff` (2026-09-23: the entry's recording switch is off, FR-1.6 — FrameLedger does not start what it will not record). *(Built 2026-09-13, PR-1b: `CaptureOrchestrator.LaunchAsync` over an `ILaunchRecorderFactory` the Agent composes with the Vulkan layer's environment — or none when FR-2.4's switch is on — and the launcher election runs after, as the console's `launch` does; the elected session is not addressable by the launch's guid.)* |
|
||||
@@ -462,6 +462,19 @@ message, and that message always re-scans.
|
||||
> before this the reason was swallowed, and a refusal looked exactly like an absent Agent). The Agent it does start
|
||||
> is watched until it exits and its exit code logged, so exit 10 — the folder was already claimed — is visible in
|
||||
> the App's log. `AgentConnectionTests` pins both.
|
||||
> **Amended 2026-09-27 (beta.10, the admin mode, D34): a start may ask Windows first.** With `capture.run_elevated` on
|
||||
> and this App a standard user's, the start is a UAC prompt owned by the App's window (`IAgentLauncher.WillAskForElevation`
|
||||
> turns the pill into *Waiting for administrator permission*), and while it is up the folder's `ElevationMarker`
|
||||
> (`Local\FrameLedger.Agent.Elevating.<hash>`) is held — `RunningAgent` reads it as "an Agent is coming", so the App never
|
||||
> prompts beside the logon task's Agent, which holds the same marker while its own prompt waits on the taskbar. A declined
|
||||
> prompt starts the standard user's Agent with `--elevation declined`; an elevated Agent that exits 11 (another account
|
||||
> answered) makes the App start standard-user Agents until it restarts.
|
||||
- **Named objects an elevated process creates state their DACL (beta.10).** An elevated token's default DACL grants
|
||||
Administrators and SYSTEM and not the user, so an object an elevated Agent creates with it cannot be opened by the same
|
||||
user's unelevated App or game: the pipe (`PipeAccessControl`), the tolerance mapping (§D) and — since beta.10 — the
|
||||
ledger's migration lock (`Infrastructure.Startup.SharedMutex`: owner the user, full access to the user, Administrators
|
||||
and SYSTEM) each carry an explicit descriptor. The instance lock and the elevation marker are only ever probed, and a
|
||||
probe that is refused reads as "held".
|
||||
- Treat the pipe as unreliable: library, history and charts must all work with the Agent offline. Only live status degrades.
|
||||
- SQLite is the source of truth for anything persisted; pipe events are refresh signals (except `SessionProgress`, which is live-only by design).
|
||||
- `CaptureRefused`, `SafetyUnhook` and (since 2026-09-25) `HookingTurnedOff` are **never** collapsed into a generic error toast — they get dedicated, explanatory UI (`08_UI` §Notifications).
|
||||
|
||||
@@ -437,6 +437,17 @@ Sections per FR-10 using the WPF UI settings idiom: `ui:CardControl`/`ui:CardExp
|
||||
|
||||
Agent section: elevation state with a plain explanation of what elevation *optionally* unlocks (CPU temperature, elevated-game attach — ~~ETW fallback~~, which no longer exists) and that it is **not required by any capture tier**; task state, Register/Repair/Remove task, "Start agent at logon", background capture toggle. Privacy: online-metadata opt-in with plain-language explanation. Legal: reopen documents.
|
||||
|
||||
> **The admin mode, beta.10 (owner decision D34; `01_ARCHITECTURE` ADR-9).** The Agent section has a switch, *Run the agent
|
||||
> as administrator* (`capture.run_elevated`, off by default). Turning it on opens a `ContentDialog`
|
||||
> (`Services.AgentAdminPrompt`, text `FrameLedger.Shared`'s `Safety_AdminMode_*`, version `agent-admin-dialog/1` in its
|
||||
> corner) whose primary button is enabled only by ticking "I understand…" and whose default button keeps standard rights;
|
||||
> declined, nothing is written. Either way the row is written and the Agent restarts — asked to stop over the pipe, its
|
||||
> instance lock waited out, the connection's next round starting it the new way — **except under a running session**,
|
||||
> which the restart would end: then the snackbar says the change applies at the Agent's next start. The elevation line
|
||||
> says why a standard user's Agent is one when Windows was asked (`HelloAck.ElevationOutcome`: declined, answered by
|
||||
> another account, could not start), and while the prompt waits the status pill reads *Waiting for administrator
|
||||
> permission* (`AgentConnectionState.Elevating`).
|
||||
|
||||
> **Built 2026-09-14 (P3 PR-8a), with three rows deferred to PR-8b and one to PR-9.** `SettingsViewModel` over
|
||||
> `Application.Settings.RegisteredSettings` (the registry of `06_DATA_MODEL` §Settings registry — every write is
|
||||
> one `settings` row, and a key the Agent reads gets the 4 s "Applied. The capture agent reads it at the next
|
||||
|
||||
+5
-1
@@ -71,7 +71,11 @@ flow, and the tests run the flow over a fake client because nothing here may tou
|
||||
connect SEEDS the running set rather than being OR-ed with it forever — before, a session running when the App
|
||||
connected held every download at `Deferred` until the next reconnect, hours after it ended.
|
||||
- **Apply:** `Shutdown` to the Agent over the pipe, the connection's relaunch held (`IAgentLink.SetLaunchHold`),
|
||||
the pipe watched until it drops (10 s; an Agent that does not stop leaves everything as it was and says so),
|
||||
the pipe watched until it drops (10 s; an Agent that does not stop leaves everything as it was and says so) —
|
||||
**and since beta.10 the data folder's instance lock watched until it is let go, within the same 10 s**: an Agent run as
|
||||
administrator (the admin mode) holds the install directory's files exactly as long as its process lives, and one that
|
||||
holds the folder without answering this App (still starting, another version) is never updated under — the apply is
|
||||
refused with `Update_AgentStillRunning` instead,
|
||||
then `WaitExitThenApplyUpdates(asset, silent: false, restart: true)` and the host ends. The restarted App
|
||||
starts the Agent beside itself as always, and when Velopack reports the restart (`OnRestarted`) the host reads
|
||||
the logon task: `Stale` (the action path moved) runs `--install-task`, this user's own task, and says so in the
|
||||
|
||||
+1
-1
@@ -88,7 +88,7 @@ Launch profiles:
|
||||
|
||||
Native debugging notes: use **`hook-harness`, never a real game**, for step-through debugging — a breakpoint inside a present hook of a real game freezes it in ways anti-cheat and drivers both dislike. Enable the Vulkan validation layers when touching `FrameLedger.VkLayer`. Application Verifier + PageHeap on the harness catches ring-buffer bugs early.
|
||||
|
||||
Agent flags: `--serve`, `--console`, `--write-crash-dump <file>` (2026-09-17: the crash-dump helper a crashing App or Agent starts; it dumps its parent and takes no pid — `10_LOGGING` §Crash handling), ~~`--diag`~~ (the App's — `FrameLedger.exe --diag`, `10_LOGGING`; the Agent answers exit 2 for it), `--install-task`, `--uninstall-task`, `--register-vklayer`, `--unregister-vklayer` (all four real since 2026-09-14, P3 PR-8b: the task is `\FrameLedger\FrameLedger.Agent` through the Task Scheduler COM API — `schtasks /Create /SC ONLOGON` is "Access is denied" unelevated on the dev box, measured — this user's logon trigger, interactive token, lowest run level; the layer registration is `17_HOOK_ENGINE` §Vulkan's HKCU value).
|
||||
Agent flags: `--serve` (since beta.10 with at most one of `--for-user <SID>` — the account an Agent started as administrator must be, else it exits 11 — or `--elevation declined|other-account|failed` — its starter asked Windows and got this; both from the admin mode, `01_ARCHITECTURE` ADR-9), `--console`, `--write-crash-dump <file>` (2026-09-17: the crash-dump helper a crashing App or Agent starts; it dumps its parent and takes no pid — `10_LOGGING` §Crash handling), ~~`--diag`~~ (the App's — `FrameLedger.exe --diag`, `10_LOGGING`; the Agent answers exit 2 for it), `--install-task`, `--uninstall-task`, `--register-vklayer`, `--unregister-vklayer` (all four real since 2026-09-14, P3 PR-8b: the task is `\FrameLedger\FrameLedger.Agent` through the Task Scheduler COM API — `schtasks /Create /SC ONLOGON` is "Access is denied" unelevated on the dev box, measured — this user's logon trigger, interactive token, lowest run level; the layer registration is `17_HOOK_ENGINE` §Vulkan's HKCU value).
|
||||
|
||||
> **Built 2026-09-10 (P2 PR-F): `--serve` and `--console`; the other five answer "not implemented in P2"
|
||||
> with exit 2** rather than being silently accepted (`--diag` is the App's anyway, `10_LOGGING`). The console
|
||||
|
||||
@@ -122,7 +122,10 @@ CPU and motherboard sensors remain LHM-only, elevated-only, PawnIO-dependent, an
|
||||
> unelevated by design, so the unprivileged layer's behaviour never depends on privilege) only when the process is
|
||||
> elevated AND `PawnIo.IsInstalled`; it takes the package sensor (`CPU Package`, `Core (Tctl/Tdie)`) and falls back to the
|
||||
> hottest core. **Unmeasured on real hardware**: exercised against a fake `ILhmComputer` only; the first elevated run
|
||||
> with PawnIO is the measurement. `HelloAck.cpuTempAvailable` reports those same two conditions (it was a constant
|
||||
> with PawnIO is the measurement — **which the user can now choose to make (beta.10, the admin mode: Settings ▸ Capture
|
||||
> agent ▸ Run the agent as administrator, `01_ARCHITECTURE` ADR-9)**; until beta.10 an elevated Agent existed only when an
|
||||
> App started as administrator happened to start it, and `PrivilegeFootprintTests` now asserts on the elevated CI runner
|
||||
> that opening this CPU group enables no privilege. `HelloAck.cpuTempAvailable` reports those same two conditions (it was a constant
|
||||
> `false`). A tick only the machine answered is still queued, under a placeholder `GpuSample` with
|
||||
> `TelemetryLayer.None` and no field. The `.partial` sensor chunk carries the three values in bits 12–14 of the
|
||||
> existing 16-bit presence mask, so an older file reads back with an empty reading.
|
||||
|
||||
@@ -862,6 +862,26 @@ injected or layered**.
|
||||
|
||||
If `OpenProcess` with the needed rights fails (protected process, higher integrity), do **not** escalate creatively. Report "cannot attach" and offer Tier-2. Never attempt to acquire privileges beyond running the Agent elevated at the user's explicit request.
|
||||
|
||||
> **The explicit request exists since beta.10 (owner decision D34, 2026-09-27): the admin mode.** An option off by default,
|
||||
> turned on through a versioned disclosure (`Safety_AdminMode_*`, `agent-admin-dialog/1`) that states what it adds, what it
|
||||
> does not change, how Windows asks and the risk of a per-user install; then **Windows asks at every start of the Agent**
|
||||
> (`01_ARCHITECTURE` ADR-9). What it does NOT do, each held by code rather than by this paragraph:
|
||||
>
|
||||
> - **It clears no finding and opens no protected process.** The guard runs exactly as unelevated: the driver scan asks
|
||||
> `NtQuerySystemInformation`, and a process an anti-cheat driver protects stays `TargetUnreadable` (D21) — elevation turns
|
||||
> "could not look" into an answer only where Windows would give any administrator one.
|
||||
> - **It enables no privilege.** An elevated token holds `SeDebugPrivilege` and `SeLoadDriverPrivilege` disabled and they
|
||||
> stay so: `AdjustTokenPrivileges`, `RtlAdjustPrivilege`, `EnterDebugMode` and the debug privilege's name may not appear
|
||||
> under `src/` (`tools/chokepoint-check.ps1`), and `PrivilegeFootprintTests` asserts on the elevated CI runner that opening
|
||||
> targets and LibreHardwareMonitor's CPU group enabled none.
|
||||
> - **It elevates no game.** A game started from FrameLedger gets the desktop shell's token (`UnelevatedProcess`); with no
|
||||
> shell to take one from, the launch is refused with that reason (`Launch_Error_1400`), never made elevated instead.
|
||||
> - **It is not silent.** Every start asks; a start that was declined serves as a standard user and says so; the prompt
|
||||
> answered by another account ends that Agent before it touches anything (exit 11).
|
||||
>
|
||||
> The residual risk is stated to the user, not solved: FrameLedger installs per user and unsigned, so a program running
|
||||
> under the account could replace its files and be run as administrator the next time the user accepts the prompt.
|
||||
|
||||
## User-facing consent
|
||||
|
||||
Enabling hooking is a **per-game** action, gated by a one-time dialog per game that states, in plain language:
|
||||
|
||||
@@ -4348,7 +4348,7 @@ Each of these is referenced by an existing doc but specified nowhere.
|
||||
|
||||
| Area | What is missing | Referenced by |
|
||||
|---|---|---|
|
||||
| **Agent lifecycle** | Scheduled-task definition, start-at-logon, how elevation is requested and persisted, what "Repair" repairs. **`--serve` exists since 2026-09-10 (P2 PR-F)** — a Generic Host around the watcher, stopped by Ctrl+C with a 15 s finalize grace — and `--install-task` / `--uninstall-task` answer "not implemented in P2"; the task definition and start-at-logon are what stays open. **One Agent per data folder since 2026-09-17** (`01_ARCHITECTURE` §Lifecycle: `AgentInstanceLock`, exit 10; beta.1 ran four after an elevated App was refused by the pipe). **Still open from that morning:** (1) the ring's single consumer is enforced across data folders only by `NoSecondRingReaderTests`' source sweep — a developer's `--console --data-dir` capture beside the installed Agent can still attach a second reader to one game's `Local\FrameLedger.Ring.<pid>`, and a runtime claim beside the mapping would close it; (2) elevation is inherited, not chosen — an App started as administrator starts an elevated Agent, which injects and writes the ledger as administrator | `08_UI` Settings, `11_UPDATER`, `12_BUILD` flags |
|
||||
| **Agent lifecycle** | Scheduled-task definition, start-at-logon, how elevation is requested and persisted, what "Repair" repairs. **`--serve` exists since 2026-09-10 (P2 PR-F)** — a Generic Host around the watcher, stopped by Ctrl+C with a 15 s finalize grace — and `--install-task` / `--uninstall-task` answer "not implemented in P2"; the task definition and start-at-logon are what stays open. **One Agent per data folder since 2026-09-17** (`01_ARCHITECTURE` §Lifecycle: `AgentInstanceLock`, exit 10; beta.1 ran four after an elevated App was refused by the pipe). **Still open from that morning:** (1) the ring's single consumer is enforced across data folders only by `NoSecondRingReaderTests`' source sweep — a developer's `--console --data-dir` capture beside the installed Agent can still attach a second reader to one game's `Local\FrameLedger.Ring.<pid>`, and a runtime claim beside the mapping would close it; (2) ~~elevation is inherited, not chosen — an App started as administrator starts an elevated Agent, which injects and writes the ledger as administrator~~ **closed 2026-09-27 (beta.10, owner decision D34): chosen** — `capture.run_elevated`, a UAC prompt at every Agent start, the logon task's Agent asking through its own prompt, and with the option off an administrator's App starts the Agent with the shell's token (`01_ARCHITECTURE` ADR-9). "How elevation is requested and persisted" is that: requested by the prompt, persisted as one settings row and never as a task's run level | `08_UI` Settings, `11_UPDATER`, `12_BUILD` flags |
|
||||
| **Session identity** | ~~`sessions` has no GUID column, yet `SessionStarted`/`StopSession`/`.partial` files are all keyed by `sessionGuid`.~~ **`sessions.session_guid` (UNIQUE) exists since 2026-09-09 (P2 PR-B), with `qpc_epoch` / `qpc_frequency` beside it.** ~~Still open: the `.partial` file format is undefined, and it is the crash-recovery artifact — PR-D's, pre-committed in HANDOFF §P2 (CRC-framed append-only chunks, the valid prefix wins)~~ **Built 2026-09-10 (P2 PR-D): `06_DATA_MODEL` §The `.partial` file, `PartialSessionFile` + `PartialRecovery`, killed at every byte in the merge gate.** What stays open here is the pipe's use of the guid (P3) | `07_IPC`, `04_CAPTURE`, `06_DATA_MODEL` |
|
||||
| ~~**Settings registry**~~ | ~~The `settings` table is key/value with no key list, defaults, types, or validation — and no message for the UI to push a changed setting to the Agent.~~ **Decided 2026-09-13 (HANDOFF §P3 decision D16)**: the key list with defaults and ranges, and *no* push message — the Agent re-reads its keys at each session start. **Built the same day (P3 PR-3):** `06_DATA_MODEL` §Settings registry (12 keys), `Application.Settings.SettingsRegistry` + `RegisteredSettings` (validating writes, tolerant reads), `SettingsRecorderPolicy` resolving `capture.min_session_s` / `telemetry.interval_ms` / `retention.raw_sessions_per_game` at each session start. **Row closed** | `06_DATA_MODEL`, FR-10 |
|
||||
| **Error taxonomy** | `07_IPC` lists `CaptureError` codes; no canonical mapping to resx keys and user-facing text, though `09_I18N` requires safety strings to be reviewed as legal text | `07_IPC`, `09_I18N` |
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
using System.Globalization;
|
||||
using System.Security.Principal;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
|
||||
namespace FrameLedger.Agent.Cli;
|
||||
|
||||
@@ -11,6 +13,13 @@ namespace FrameLedger.Agent.Cli;
|
||||
/// <b><c>--data-dir</c> exists only under <c>--console</c></b> (HANDOFF §P2 decision D6): an integration test
|
||||
/// needs a scratch ledger, and CI must never touch the profile. <c>--serve</c> with it is an error rather than an
|
||||
/// ignored option, because an ignored option is how the product directory becomes selectable by accident.
|
||||
/// <para>
|
||||
/// <b><c>--serve</c> takes two options since beta.10, and only these</b> (the Agent's admin mode, owner decision D34):
|
||||
/// <c>--for-user <SID></c>, which the starter passes to the Agent it asked Windows to elevate — the Agent refuses to run
|
||||
/// as any other account (<c>AgentElevation.ExitOtherAccount</c>) — and <c>--elevation <outcome></c>, which says the
|
||||
/// starter asked and was not granted, so this Agent does not ask again. Neither names a directory, a target or a check; the
|
||||
/// data folder is still the profile's and nothing else.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
internal sealed record AgentCommandLine
|
||||
{
|
||||
@@ -29,7 +38,7 @@ internal sealed record AgentCommandLine
|
||||
};
|
||||
|
||||
private const string _usage =
|
||||
"usage: FrameLedger.Agent --serve\n"
|
||||
"usage: FrameLedger.Agent --serve [--for-user <SID> | --elevation declined|other-account|failed]\n"
|
||||
+ " FrameLedger.Agent --register-vklayer | --unregister-vklayer | --install-task | --uninstall-task\n"
|
||||
+ " FrameLedger.Agent --write-crash-dump <file> (started by a crashing App or Agent; dumps that parent)\n"
|
||||
+ " FrameLedger.Agent --console [--data-dir <dir>] consent list | consent grant --exe <path> | consent revoke --exe <path>\n"
|
||||
@@ -59,6 +68,12 @@ internal sealed record AgentCommandLine
|
||||
|
||||
public string? DataDirectory { get; init; }
|
||||
|
||||
/// <summary><c>--serve --for-user</c>: the account whose Agent this elevated process must be (beta.10, D34).</summary>
|
||||
public string? ForUser { get; init; }
|
||||
|
||||
/// <summary><c>--serve --elevation</c>: the starter asked for elevation and got this instead (<c>AgentElevation.Refusals</c>).</summary>
|
||||
public string? ElevationRefusal { get; init; }
|
||||
|
||||
/// <summary>The file <see cref="AgentVerb.WriteCrashDump"/> writes — a path, never a pid.</summary>
|
||||
public string? CrashDumpFile { get; init; }
|
||||
|
||||
@@ -97,9 +112,7 @@ internal sealed record AgentCommandLine
|
||||
|
||||
if (string.Equals(args[0], "--serve", StringComparison.Ordinal))
|
||||
{
|
||||
return args.Length == 1
|
||||
? new AgentCommandLine { Verb = AgentVerb.Serve }
|
||||
: new AgentCommandLine { Error = "--serve takes no options; --data-dir exists only under --console (the product directory is not selectable)" };
|
||||
return ParseServe(args[1..]);
|
||||
}
|
||||
|
||||
if (!string.Equals(args[0], "--console", StringComparison.Ordinal))
|
||||
@@ -110,6 +123,41 @@ internal sealed record AgentCommandLine
|
||||
return ParseConsole(args[1..]);
|
||||
}
|
||||
|
||||
/// <summary><c>--serve</c>, alone or with ONE of its two admin-mode options (beta.10).</summary>
|
||||
private static AgentCommandLine ParseServe(string[] rest)
|
||||
{
|
||||
const string onlyThese = "--serve takes only --for-user <SID> or --elevation declined|other-account|failed (the agent's admin mode); "
|
||||
+ "--data-dir exists only under --console (the product directory is not selectable)";
|
||||
if (rest.Length == 0)
|
||||
{
|
||||
return new AgentCommandLine { Verb = AgentVerb.Serve };
|
||||
}
|
||||
|
||||
if (rest.Length != 2)
|
||||
{
|
||||
return new AgentCommandLine { Error = onlyThese };
|
||||
}
|
||||
|
||||
switch (rest[0])
|
||||
{
|
||||
case "--for-user":
|
||||
try
|
||||
{
|
||||
// A SID in its string form, validated as one: the Agent compares it with its own token's user.
|
||||
return new AgentCommandLine { Verb = AgentVerb.Serve, ForUser = new SecurityIdentifier(rest[1]).Value };
|
||||
}
|
||||
catch (ArgumentException)
|
||||
{
|
||||
return new AgentCommandLine { Error = $"--for-user needs a SID, not '{rest[1]}'" };
|
||||
}
|
||||
|
||||
case "--elevation" when AgentElevation.Refusals.Contains(rest[1], StringComparer.Ordinal):
|
||||
return new AgentCommandLine { Verb = AgentVerb.Serve, ElevationRefusal = rest[1] };
|
||||
default:
|
||||
return new AgentCommandLine { Error = onlyThese };
|
||||
}
|
||||
}
|
||||
|
||||
private static AgentCommandLine ParseConsole(string[] rest)
|
||||
{
|
||||
(AgentVerb verb, int at, int words) = VerbOf(rest);
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
namespace FrameLedger.Agent.Composition;
|
||||
|
||||
/// <summary>
|
||||
/// The admin mode's answer at this Agent's start (beta.10, owner decision D34): registered by <c>--serve</c> alone, read into
|
||||
/// <c>HelloAck.ElevationOutcome</c>. Null when nobody asked — the option off, or elevation inherited from whoever started it.
|
||||
/// </summary>
|
||||
/// <param name="Outcome">One of <c>Infrastructure.Startup.AgentElevation</c>'s outcomes, or null.</param>
|
||||
internal sealed record AgentElevationState(string? Outcome);
|
||||
@@ -9,7 +9,7 @@ namespace FrameLedger.Agent.Composition;
|
||||
/// <summary>What <c>HelloAck</c> says about this process, read once at composition.</summary>
|
||||
internal static class AgentIdentityFactory
|
||||
{
|
||||
public static AgentIdentity OfThisProcess(string vkLayerDirectory)
|
||||
public static AgentIdentity OfThisProcess(string vkLayerDirectory, string? elevationOutcome = null)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(vkLayerDirectory);
|
||||
string buildId = NativeAntiCheatGuard.BuildId();
|
||||
@@ -27,7 +27,9 @@ internal static class AgentIdentityFactory
|
||||
// D14: the FR-2.1 text this build stamps against; the App compares it with its own before showing the dialog.
|
||||
DisclosureVersion: SafetyDisclosure.Version,
|
||||
// D33: the user-mode exception's disclosure, under the same rule.
|
||||
ExceptionDisclosureVersion: AntiCheatExceptionDisclosure.Version);
|
||||
ExceptionDisclosureVersion: AntiCheatExceptionDisclosure.Version,
|
||||
// beta.10 (D34): what the admin mode's prompt answered at this start; null when nobody asked.
|
||||
ElevationOutcome: elevationOutcome);
|
||||
}
|
||||
|
||||
private static string Version()
|
||||
|
||||
@@ -215,7 +215,7 @@ internal static class AgentServices
|
||||
services.TryAddSingleton<IAgentLifetime, NoAgentLifetime>();
|
||||
services.AddSingleton(static sp => CommandHandler(sp));
|
||||
services.AddSingleton<IIpcRequestHandler>(static sp => new AgentRequestHandler(
|
||||
AgentIdentityFactory.OfThisProcess(sp.GetRequiredService<AgentPaths>().VkLayerDirectory),
|
||||
AgentIdentityFactory.OfThisProcess(sp.GetRequiredService<AgentPaths>().VkLayerDirectory, sp.GetService<AgentElevationState>()?.Outcome),
|
||||
TelemetryDescriptor(),
|
||||
() => sp.GetRequiredService<SessionEventPublisher>().Status,
|
||||
() => sp.GetRequiredService<AgentCommandHandler>()));
|
||||
|
||||
@@ -14,7 +14,12 @@
|
||||
//
|
||||
// The maintenance flags (P3 PR-8b) — --register-vklayer, --unregister-vklayer, --install-task, --uninstall-task —
|
||||
// run over the product directory and exit; --diag is the App's (10_LOGGING) and answers "not implemented", exit 2.
|
||||
//
|
||||
// The admin mode (beta.10, owner decision D34): with capture.run_elevated on, a plain --serve that is not elevated — the
|
||||
// logon task's — asks Windows once (a UAC prompt on the taskbar) to start an elevated Agent for this user and hands over to
|
||||
// it; declined, it serves as before and says so. Decided before the folder is claimed or anything is written.
|
||||
|
||||
using System.Diagnostics;
|
||||
using FrameLedger.Agent.Cli;
|
||||
using FrameLedger.Agent.Composition;
|
||||
using FrameLedger.Agent.Hosting;
|
||||
@@ -51,6 +56,12 @@ internal static class Program
|
||||
}
|
||||
|
||||
AgentPaths paths = cmd.DataDirectory is { } dir ? new AgentPaths(Path.GetFullPath(dir)) : AgentPaths.Default;
|
||||
ElevationDecision elevation = cmd.Verb == AgentVerb.Serve ? await DecideElevationAsync(cmd, paths).ConfigureAwait(false) : ElevationDecision.NotAsked;
|
||||
if (elevation.Exit is { } decided)
|
||||
{
|
||||
return decided;
|
||||
}
|
||||
|
||||
using AgentInstanceLock? claim = ClaimDataDirectory(cmd.Verb, paths, out bool heldElsewhere);
|
||||
if (heldElsewhere)
|
||||
{
|
||||
@@ -59,36 +70,11 @@ internal static class Program
|
||||
|
||||
ConfigureLogging(paths);
|
||||
HookCrashHandlers(paths);
|
||||
LogElevation(elevation);
|
||||
|
||||
try
|
||||
{
|
||||
// Before anything else. The guard reads this file on every evaluation and refuses every title
|
||||
// when it is absent, so a capture started before the seed lands would fail for a reason that
|
||||
// has nothing to do with the game (§S20).
|
||||
RulesSeedOutcome seeded = await new RulesSeeder(new FileSystemRulesStore()).EnsureSeededAsync().ConfigureAwait(false);
|
||||
AgentConsole.Line($"rules: {Describe(seeded)}");
|
||||
Log.Information("rules: {Outcome}", seeded);
|
||||
if (seeded is RulesSeedOutcome.WriteFailed or RulesSeedOutcome.PackagedSeedUnusable)
|
||||
{
|
||||
return _exitRulesFailed;
|
||||
}
|
||||
|
||||
LedgerDatabase? db = await OpenLedgerOrSayWhyAsync(cmd.Verb, paths).ConfigureAwait(false);
|
||||
if (db is null)
|
||||
{
|
||||
return cmd.Verb == AgentVerb.DbPath ? _exitOk : _exitLedgerRefused;
|
||||
}
|
||||
|
||||
await using (db.ConfigureAwait(false))
|
||||
{
|
||||
return cmd.Verb switch
|
||||
{
|
||||
AgentVerb.Serve => await ServeAsync(db, paths).ConfigureAwait(false),
|
||||
AgentVerb.RegisterVkLayer or AgentVerb.UnregisterVkLayer or AgentVerb.InstallTask or AgentVerb.UninstallTask =>
|
||||
await new MaintenanceVerbs(db, paths).RunAsync(cmd).ConfigureAwait(false),
|
||||
_ => await ConsoleAsync(cmd, db, paths).ConfigureAwait(false),
|
||||
};
|
||||
}
|
||||
return await RunAsync(cmd, paths, elevation.Outcome).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is not OutOfMemoryException)
|
||||
{
|
||||
@@ -103,6 +89,38 @@ internal static class Program
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The rules, the ledger and the verb, once the folder is claimed and the log is open.</summary>
|
||||
private static async Task<int> RunAsync(AgentCommandLine cmd, AgentPaths paths, string? elevationOutcome)
|
||||
{
|
||||
// Before anything else. The guard reads this file on every evaluation and refuses every title
|
||||
// when it is absent, so a capture started before the seed lands would fail for a reason that
|
||||
// has nothing to do with the game (§S20).
|
||||
RulesSeedOutcome seeded = await new RulesSeeder(new FileSystemRulesStore()).EnsureSeededAsync().ConfigureAwait(false);
|
||||
AgentConsole.Line($"rules: {Describe(seeded)}");
|
||||
Log.Information("rules: {Outcome}", seeded);
|
||||
if (seeded is RulesSeedOutcome.WriteFailed or RulesSeedOutcome.PackagedSeedUnusable)
|
||||
{
|
||||
return _exitRulesFailed;
|
||||
}
|
||||
|
||||
LedgerDatabase? db = await OpenLedgerOrSayWhyAsync(cmd.Verb, paths).ConfigureAwait(false);
|
||||
if (db is null)
|
||||
{
|
||||
return cmd.Verb == AgentVerb.DbPath ? _exitOk : _exitLedgerRefused;
|
||||
}
|
||||
|
||||
await using (db.ConfigureAwait(false))
|
||||
{
|
||||
return cmd.Verb switch
|
||||
{
|
||||
AgentVerb.Serve => await ServeAsync(db, paths, elevationOutcome).ConfigureAwait(false),
|
||||
AgentVerb.RegisterVkLayer or AgentVerb.UnregisterVkLayer or AgentVerb.InstallTask or AgentVerb.UninstallTask =>
|
||||
await new MaintenanceVerbs(db, paths).RunAsync(cmd).ConfigureAwait(false),
|
||||
_ => await ConsoleAsync(cmd, db, paths).ConfigureAwait(false),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>A usage error or a flag this binary does not implement is answered before any file is touched.</summary>
|
||||
private static int? AnswerWithoutLogging(AgentCommandLine cmd)
|
||||
{
|
||||
@@ -164,6 +182,83 @@ internal static class Program
|
||||
return claim;
|
||||
}
|
||||
|
||||
/// <summary>What the admin mode decided at this start: the outcome <c>HelloAck</c> reports, and an exit code when this process stops here.</summary>
|
||||
private sealed record ElevationDecision(string? Outcome, int? Exit, string? Detail)
|
||||
{
|
||||
public static readonly ElevationDecision NotAsked = new(null, null, null);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The admin mode (beta.10, D34), before anything is claimed or written: an elevated Agent started for another account
|
||||
/// stops (exit 11); an Agent told the answer was no says so; a plain <c>--serve</c> with the option on and no elevation —
|
||||
/// the logon task's — asks Windows once and hands over to the elevated Agent, or carries on as a standard user's.
|
||||
/// </summary>
|
||||
private static async Task<ElevationDecision> DecideElevationAsync(AgentCommandLine cmd, AgentPaths paths)
|
||||
{
|
||||
if (cmd.ForUser is { } sid)
|
||||
{
|
||||
if (!AgentElevation.IsCurrentUser(sid))
|
||||
{
|
||||
// The prompt was answered with another account's credentials: its %LOCALAPPDATA% is not this user's ledger.
|
||||
AgentConsole.Problem($"this elevated Agent runs as another account than the one that asked ({sid}); it exits (exit {AgentElevation.ExitOtherAccount})");
|
||||
return new ElevationDecision(null, AgentElevation.ExitOtherAccount, null);
|
||||
}
|
||||
|
||||
return new ElevationDecision(Environment.IsPrivilegedProcess ? AgentElevation.Granted : null, null, "started for this user by a UAC prompt");
|
||||
}
|
||||
|
||||
if (cmd.ElevationRefusal is { } refusal)
|
||||
{
|
||||
return new ElevationDecision(refusal, null, "the process that started this Agent asked Windows and got: " + refusal);
|
||||
}
|
||||
|
||||
if (Environment.IsPrivilegedProcess || !RunElevatedSetting.Read(paths.Database) || AgentInstanceLock.IsHeld(paths.DataDirectory))
|
||||
{
|
||||
// Elevated already (inherited), the option off, or an Agent already serves: nothing to ask; the claim decides the rest.
|
||||
return ElevationDecision.NotAsked;
|
||||
}
|
||||
|
||||
using ElevationMarker? marker = ElevationMarker.TryAcquire(paths.DataDirectory);
|
||||
if (marker is null)
|
||||
{
|
||||
AgentConsole.Problem($"another FrameLedger Agent is being started as administrator for {paths.DataDirectory}; this one exits (exit {AgentInstanceLock.ExitHeldElsewhere})");
|
||||
return new ElevationDecision(null, AgentInstanceLock.ExitHeldElsewhere, null);
|
||||
}
|
||||
|
||||
string arguments = "--serve --for-user " + AgentElevation.CurrentUserSid();
|
||||
using Process? elevated = AgentElevation.Start(Environment.ProcessPath ?? Path.Combine(AppContext.BaseDirectory, "FrameLedger.Agent.exe"),
|
||||
arguments, ownerWindow: 0, out string? refused, out int? error);
|
||||
if (elevated is null)
|
||||
{
|
||||
return new ElevationDecision(refused, null, $"the UAC prompt was {(string.Equals(refused, AgentElevation.Declined, StringComparison.Ordinal) ? "declined" : "not shown")} (error {error?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "none"})");
|
||||
}
|
||||
|
||||
(bool claimed, int? code) = await AgentElevation.WaitForClaimAsync(elevated, paths.DataDirectory, TimeSpan.FromMinutes(2)).ConfigureAwait(false);
|
||||
if (claimed)
|
||||
{
|
||||
// Handed over: the elevated Agent logs its own start; this one writes nothing and leaves.
|
||||
return new ElevationDecision(null, _exitOk, null);
|
||||
}
|
||||
|
||||
return code == AgentElevation.ExitOtherAccount
|
||||
? new ElevationDecision(AgentElevation.OtherAccount, null, "the UAC prompt was answered with another account, whose Agent refused to run")
|
||||
: new ElevationDecision(AgentElevation.Failed, null, $"the elevated Agent did not start serving (exit {code?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "none"})");
|
||||
}
|
||||
|
||||
/// <summary>The decision in the log, and what an elevated Agent's token has enabled (read, never changed: TokenPrivileges).</summary>
|
||||
private static void LogElevation(ElevationDecision elevation)
|
||||
{
|
||||
if (elevation.Outcome is { } outcome)
|
||||
{
|
||||
Log.Information("elevation: {Outcome} — {Detail}", outcome, elevation.Detail);
|
||||
}
|
||||
|
||||
if (Environment.IsPrivilegedProcess)
|
||||
{
|
||||
Log.Information("elevation: this Agent runs as administrator; enabled privileges: {Privileges}", string.Join(", ", TokenPrivileges.Enabled()));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Null when a print verb refuses the ledger — at another schema, or not there — said on the console and in the log
|
||||
/// rather than as a crash: nothing about this machine is broken.
|
||||
@@ -236,9 +331,11 @@ internal static class Program
|
||||
}
|
||||
|
||||
/// <summary>The product's mode: a Generic Host around the watcher, stopped by Ctrl+C or the service manager.</summary>
|
||||
private static async Task<int> ServeAsync(LedgerDatabase db, AgentPaths paths)
|
||||
private static async Task<int> ServeAsync(LedgerDatabase db, AgentPaths paths, string? elevationOutcome)
|
||||
{
|
||||
HostApplicationBuilder builder = Host.CreateApplicationBuilder();
|
||||
// The admin mode's answer at this start (beta.10), for HelloAck.
|
||||
builder.Services.AddSingleton(new AgentElevationState(elevationOutcome));
|
||||
// The host's log into agent-*.log (2026-09-23). A background service that threw stopped the host with nothing in
|
||||
// the file: the Generic Host logs that through Microsoft.Extensions.Logging, which was never routed here.
|
||||
builder.Services.AddSerilog();
|
||||
|
||||
@@ -277,6 +277,8 @@ public partial class App : System.Windows.Application
|
||||
// D33 (owner decision 2026-09-26): the user-mode exception's disclosure and the request it ends in; the list is
|
||||
// Settings', the button on a blocked game's page.
|
||||
builder.Services.AddSingleton<IAntiCheatExceptionPrompt, AntiCheatExceptionPrompt>();
|
||||
// The admin mode's disclosure (beta.10, D34), shown before capture.run_elevated is turned on.
|
||||
builder.Services.AddSingleton<IAgentAdminPrompt, AgentAdminPrompt>();
|
||||
builder.Services.AddSingleton<AntiCheatExceptions>();
|
||||
|
||||
AddLibrary(builder.Services);
|
||||
@@ -308,7 +310,8 @@ public partial class App : System.Windows.Application
|
||||
/// <summary>The Agent over the pipe (07_IPC §Client behavior): connect, start it when it is not there, tell the shell.</summary>
|
||||
private static void AddAgentLink(IServiceCollection services)
|
||||
{
|
||||
services.AddSingleton<IAgentLauncher, AgentLauncher>();
|
||||
// The admin mode's prompt (beta.10) belongs to the main window; the handle is read when a start asks, never earlier.
|
||||
services.AddSingleton<IAgentLauncher>(static sp => AgentLauncher.ForApp(() => sp.GetRequiredService<ShellHost>().Handle));
|
||||
services.AddSingleton(static sp => new AgentConnection(
|
||||
sp.GetRequiredService<IAgentLauncher>(),
|
||||
static () => new PipeClient(),
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
<UserControl x:Class="FrameLedger.App.Dialogs.AgentAdminDialogContent"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
|
||||
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
|
||||
d:DataContext="{d:DesignInstance Type=vm:AgentAdminDialogViewModel}"
|
||||
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
|
||||
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
|
||||
mc:Ignorable="d"
|
||||
MaxWidth="640">
|
||||
<!--
|
||||
The admin mode's disclosure (beta.10, D34; 19_SAFETY §Elevated targets), text from FrameLedger.Shared's
|
||||
Safety_AdminMode_* only, versioned by AgentAdminDisclosure.Version. It states what the option adds, what it does not
|
||||
change, how Windows asks, and the risk; every colour is a theme brush.
|
||||
-->
|
||||
<ScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
|
||||
<StackPanel>
|
||||
<ui:TextBlock Text="{x:Static vm:AgentAdminDialogViewModel.Intro}" TextWrapping="Wrap" />
|
||||
<ui:TextBlock Margin="0,14,0,0" Text="{x:Static vm:AgentAdminDialogViewModel.Adds}" TextWrapping="Wrap" />
|
||||
<ui:TextBlock Margin="0,8,0,0" Text="{x:Static vm:AgentAdminDialogViewModel.Unchanged}" TextWrapping="Wrap" />
|
||||
<ui:TextBlock Margin="0,8,0,0" Text="{x:Static vm:AgentAdminDialogViewModel.Prompt}" TextWrapping="Wrap" />
|
||||
|
||||
<Border Margin="0,14,0,0" Padding="12" CornerRadius="6" Background="{DynamicResource CardBackgroundFillColorDefaultBrush}">
|
||||
<ui:TextBlock FontWeight="SemiBold" Text="{x:Static vm:AgentAdminDialogViewModel.Risk}" TextWrapping="Wrap" />
|
||||
</Border>
|
||||
|
||||
<CheckBox x:Name="Acceptance"
|
||||
Margin="0,18,0,0"
|
||||
AutomationProperties.Name="{x:Static vm:AgentAdminDialogViewModel.AcceptText}"
|
||||
Content="{x:Static vm:AgentAdminDialogViewModel.AcceptText}"
|
||||
IsChecked="{Binding Accepted, Mode=TwoWay}" />
|
||||
<ui:TextBlock Margin="0,12,0,0" HorizontalAlignment="Right" Appearance="Tertiary" Text="{x:Static vm:AgentAdminDialogViewModel.Version}" />
|
||||
</StackPanel>
|
||||
</ScrollViewer>
|
||||
</UserControl>
|
||||
@@ -0,0 +1,18 @@
|
||||
using System.Windows.Controls;
|
||||
using FrameLedger.App.ViewModels;
|
||||
|
||||
namespace FrameLedger.App.Dialogs;
|
||||
|
||||
/// <summary>The body of the admin mode's <c>ContentDialog</c>; the buttons are the dialog's own (<see cref="Services.AgentAdminPrompt"/>).</summary>
|
||||
public partial class AgentAdminDialogContent : UserControl
|
||||
{
|
||||
public AgentAdminDialogContent(AgentAdminDialogViewModel viewModel)
|
||||
{
|
||||
ViewModel = viewModel ?? throw new ArgumentNullException(nameof(viewModel));
|
||||
DataContext = viewModel;
|
||||
InitializeComponent();
|
||||
Loaded += (_, _) => Acceptance.Focus();
|
||||
}
|
||||
|
||||
public AgentAdminDialogViewModel ViewModel { get; }
|
||||
}
|
||||
@@ -224,6 +224,16 @@
|
||||
</ui:CardExpander.Header>
|
||||
<ui:TextBlock Appearance="Secondary" Text="{x:Static res:Strings.Settings_Agent_Elevation_Body}" TextWrapping="Wrap" />
|
||||
</ui:CardExpander>
|
||||
<!-- beta.10, the admin mode (D34): off by default; on shows the disclosure, and Windows asks at every Agent start. -->
|
||||
<ui:CardControl Margin="0,8,0,0" Icon="{ui:SymbolIcon Shield24}">
|
||||
<ui:CardControl.Header>
|
||||
<StackPanel>
|
||||
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static res:Strings.Settings_Agent_RunElevated_Label}" />
|
||||
<ui:TextBlock MaxWidth="560" HorizontalAlignment="Left" Appearance="Secondary" Text="{x:Static res:Strings.Settings_Agent_RunElevated_Body}" TextWrapping="Wrap" />
|
||||
</StackPanel>
|
||||
</ui:CardControl.Header>
|
||||
<ui:ToggleSwitch AutomationProperties.Name="{x:Static res:Strings.Settings_Agent_RunElevated_Label}" IsChecked="{Binding ViewModel.RunElevated, Mode=TwoWay}" />
|
||||
</ui:CardControl>
|
||||
<ui:CardControl Margin="0,8,0,0" Icon="{ui:SymbolIcon CalendarClock24}">
|
||||
<ui:CardControl.Header>
|
||||
<StackPanel>
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
using System.Windows.Data;
|
||||
using FrameLedger.App.Dialogs;
|
||||
using FrameLedger.App.ViewModels;
|
||||
using Wpf.Ui;
|
||||
using Wpf.Ui.Controls;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>
|
||||
/// The admin mode's disclosure in WPF UI, the same shape as D33's (<see cref="AntiCheatExceptionPrompt"/>): the primary button
|
||||
/// is bound to the ticked acceptance and disabled until it is ticked; the close button keeps standard rights and is the
|
||||
/// default, so Enter never turns the mode on.
|
||||
/// </summary>
|
||||
public sealed class AgentAdminPrompt : IAgentAdminPrompt
|
||||
{
|
||||
private readonly IContentDialogService _dialogs;
|
||||
|
||||
public AgentAdminPrompt(IContentDialogService dialogs) => _dialogs = dialogs ?? throw new ArgumentNullException(nameof(dialogs));
|
||||
|
||||
public async Task<bool> ShowAsync(CancellationToken ct = default)
|
||||
{
|
||||
var viewModel = new AgentAdminDialogViewModel();
|
||||
var dialog = new ContentDialog
|
||||
{
|
||||
Title = AgentAdminDialogViewModel.Title,
|
||||
Content = new AgentAdminDialogContent(viewModel),
|
||||
PrimaryButtonText = AgentAdminDialogViewModel.TurnOnText,
|
||||
CloseButtonText = AgentAdminDialogViewModel.CancelText,
|
||||
DefaultButton = ContentDialogButton.Close,
|
||||
IsPrimaryButtonEnabled = false,
|
||||
DialogMaxWidth = 700,
|
||||
};
|
||||
_ = dialog.SetBinding(ContentDialog.IsPrimaryButtonEnabledProperty,
|
||||
new Binding(nameof(AgentAdminDialogViewModel.Accepted)) { Source = viewModel, Mode = BindingMode.OneWay });
|
||||
|
||||
ContentDialogResult result = await _dialogs.ShowAsync(dialog, ct).ConfigureAwait(true);
|
||||
return result == ContentDialogResult.Primary && viewModel.Accepted;
|
||||
}
|
||||
}
|
||||
@@ -151,7 +151,8 @@ public sealed class AgentConnection : IAgentLink, IAsyncDisposable
|
||||
running = _launcher.RunningAgent;
|
||||
if (running is null)
|
||||
{
|
||||
Set(AgentConnectionState.Starting, null, null);
|
||||
// The admin mode (beta.10): the start blocks while Windows' prompt waits for its answer, and the pill says why.
|
||||
Set(_launcher.WillAskForElevation ? AgentConnectionState.Elevating : AgentConnectionState.Starting, null, null);
|
||||
if (_launcher.TryStart())
|
||||
{
|
||||
Interlocked.Increment(ref _launches);
|
||||
|
||||
@@ -17,4 +17,10 @@ public enum AgentConnectionState
|
||||
|
||||
/// <summary>No Agent executable is beside this one; nothing to start, rounds continue in case one appears.</summary>
|
||||
Missing,
|
||||
|
||||
/// <summary>
|
||||
/// The Agent is being started as administrator (beta.10, the admin mode): Windows' prompt is up, owned by this window or
|
||||
/// flashing on the taskbar, and the round waits for its answer.
|
||||
/// </summary>
|
||||
Elevating,
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using FrameLedger.Infrastructure.Persistence;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using Serilog;
|
||||
|
||||
@@ -8,14 +9,29 @@ namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>Starts the Agent beside this executable, as its own process — it must outlive the App (background capture).</summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// Never a second one (2026-09-17): <see cref="RunningAgent"/> probes the data folder's <see cref="AgentInstanceLock"/>,
|
||||
/// and the last Agent this App started is watched until it exits, with its exit code logged — exit
|
||||
/// <see cref="AgentInstanceLock.ExitHeldElsewhere"/> is an Agent that found the folder already claimed.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>The admin mode</b> (beta.10, owner decision D34). With <c>capture.run_elevated</c> on and this App a standard user's,
|
||||
/// Windows is asked — a UAC prompt owned by the App's window — every time this App starts the Agent. Accepted: the Agent
|
||||
/// starts as administrator for THIS user (<c>--for-user</c>). Declined: the Agent starts as a standard user and says so
|
||||
/// (<c>--elevation declined</c>), and the answer is not asked again for that start. Answered with another account: that
|
||||
/// account's Agent refuses to run (exit 11), and until this App restarts it starts the standard user's instead of asking
|
||||
/// again. With the option off and this App elevated, the Agent starts with the desktop shell's token — the option is the
|
||||
/// only thing that makes the Agent an administrator's. While a prompt is up the folder's <see cref="ElevationMarker"/> is
|
||||
/// held, so the logon task's Agent does not prompt beside it.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class AgentLauncher : IAgentLauncher
|
||||
{
|
||||
private readonly string _dataDirectory;
|
||||
private readonly Func<bool> _runElevated;
|
||||
private readonly Func<nint> _ownerWindow;
|
||||
private Task _lastStarted = Task.CompletedTask;
|
||||
private volatile bool _otherAccountAnswered;
|
||||
|
||||
public AgentLauncher()
|
||||
: this(UiPaths.DataDirectory)
|
||||
@@ -23,8 +39,15 @@ public sealed class AgentLauncher : IAgentLauncher
|
||||
}
|
||||
|
||||
/// <summary>A launcher that probes <paramref name="dataDirectory"/>'s claim — a test's folder, never the user's.</summary>
|
||||
internal AgentLauncher(string dataDirectory) =>
|
||||
internal AgentLauncher(string dataDirectory, Func<bool>? runElevated = null, Func<nint>? ownerWindow = null)
|
||||
{
|
||||
_dataDirectory = dataDirectory ?? throw new ArgumentNullException(nameof(dataDirectory));
|
||||
_runElevated = runElevated ?? (() => RunElevatedSetting.Read(Path.Combine(_dataDirectory, LedgerPaths.DatabaseFileName)));
|
||||
_ownerWindow = ownerWindow ?? (static () => 0);
|
||||
}
|
||||
|
||||
/// <summary>The launcher the App composes: the user's folder, and the main window as the prompt's owner.</summary>
|
||||
public static AgentLauncher ForApp(Func<nint> ownerWindow) => new(UiPaths.DataDirectory, ownerWindow: ownerWindow);
|
||||
|
||||
private static string AgentPath => Path.Combine(AppContext.BaseDirectory, "FrameLedger.Agent.exe");
|
||||
|
||||
@@ -33,9 +56,13 @@ public sealed class AgentLauncher : IAgentLauncher
|
||||
/// <inheritdoc />
|
||||
public string? RunningAgent =>
|
||||
AgentInstanceLock.IsHeld(_dataDirectory) ? $"an Agent already holds {_dataDirectory}"
|
||||
: ElevationMarker.IsHeld(_dataDirectory) ? "an Agent is being started as administrator (a UAC prompt may be waiting on the taskbar)"
|
||||
: !_lastStarted.IsCompleted ? "the Agent this App started last is still starting"
|
||||
: null;
|
||||
|
||||
/// <inheritdoc />
|
||||
public bool WillAskForElevation => !Environment.IsPrivilegedProcess && !_otherAccountAnswered && _runElevated();
|
||||
|
||||
public bool TryStart()
|
||||
{
|
||||
if (!CanLaunch)
|
||||
@@ -43,10 +70,88 @@ public sealed class AgentLauncher : IAgentLauncher
|
||||
return false;
|
||||
}
|
||||
|
||||
bool wanted = _runElevated();
|
||||
if (wanted && !Environment.IsPrivilegedProcess)
|
||||
{
|
||||
return _otherAccountAnswered ? StartPlain("--serve --elevation " + AgentElevation.OtherAccount) : StartElevated();
|
||||
}
|
||||
|
||||
return !wanted && Environment.IsPrivilegedProcess ? StartWithShellToken() : StartPlain("--serve");
|
||||
}
|
||||
|
||||
/// <summary>The UAC prompt; declined or failed, the standard user's Agent, which says so.</summary>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2025:Ensure tasks using 'IDisposable' instances complete before the instances are disposed",
|
||||
Justification = "the process and the marker are handed to the watch task, which disposes both; this method disposes neither after the handover")]
|
||||
private bool StartElevated()
|
||||
{
|
||||
ElevationMarker? marker = ElevationMarker.TryAcquire(_dataDirectory);
|
||||
if (marker is null)
|
||||
{
|
||||
// Someone else's prompt is up (the logon task's Agent): its answer starts the Agent; this round starts nothing.
|
||||
Log.Information("agent: another start is asking for administrator rights; not asking twice");
|
||||
return false;
|
||||
}
|
||||
|
||||
Log.Information("agent: asking Windows to start the Agent as administrator (capture.run_elevated)");
|
||||
Process? started = AgentElevation.Start(AgentPath, "--serve --for-user " + AgentElevation.CurrentUserSid(), _ownerWindow(), out string? refusal, out int? error);
|
||||
if (started is null)
|
||||
{
|
||||
marker.Dispose();
|
||||
Log.Information("agent: the administrator prompt was {Refusal} (error {Error}); starting the Agent as a standard user", refusal, error);
|
||||
return StartPlain("--serve --elevation " + (refusal ?? AgentElevation.Failed));
|
||||
}
|
||||
|
||||
Log.Information("agent: started {Path} as administrator (pid {Pid})", AgentPath, started.Id);
|
||||
_lastStarted = WatchElevatedAsync(started, marker);
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>This App is elevated and the option is off: the Agent gets the desktop shell's token, as a double-click would.</summary>
|
||||
private bool StartWithShellToken()
|
||||
{
|
||||
(int Pid, IDisposable Process)? started = UnelevatedProcess.Start(AgentPath, "--serve", AppContext.BaseDirectory,
|
||||
new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), out int error);
|
||||
if (started is not { } s)
|
||||
{
|
||||
// No shell to take a standard user's token from: the Agent inherits this App's elevation, as before beta.10, and
|
||||
// the Settings page says it runs elevated.
|
||||
Log.Warning("agent: could not start the Agent as a standard user (error {Error}); it inherits this App's elevation", error);
|
||||
return StartPlain("--serve");
|
||||
}
|
||||
|
||||
Process? agent = Watchable(s);
|
||||
if (agent is not null)
|
||||
{
|
||||
Log.Information("agent: started {Path} --serve (pid {Pid}) as a standard user; this App is elevated and the admin mode is off", AgentPath, s.Pid);
|
||||
_lastStarted = WatchUntilExitAsync(agent);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>The started Agent as a <see cref="Process"/>, taken while the start's own handle still holds its id; null when it is gone already.</summary>
|
||||
private static Process? Watchable((int Pid, IDisposable Process) started)
|
||||
{
|
||||
using (started.Process)
|
||||
{
|
||||
try
|
||||
{
|
||||
return Process.GetProcessById(started.Pid);
|
||||
}
|
||||
catch (ArgumentException)
|
||||
{
|
||||
// Gone already; its exit code is lost with it, and the next round says whether an Agent answers.
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool StartPlain(string arguments)
|
||||
{
|
||||
Process? started;
|
||||
try
|
||||
{
|
||||
started = Process.Start(new ProcessStartInfo(AgentPath, "--serve")
|
||||
started = Process.Start(new ProcessStartInfo(AgentPath, arguments)
|
||||
{
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true,
|
||||
@@ -64,22 +169,54 @@ public sealed class AgentLauncher : IAgentLauncher
|
||||
return false;
|
||||
}
|
||||
|
||||
// An elevated App starts an elevated Agent: the token is inherited, and it is what 07_IPC §C's owner check is about.
|
||||
Log.Information("agent: started {Path} --serve (pid {Pid}{Elevated})", AgentPath, started.Id,
|
||||
// An elevated App starts an elevated Agent here only when the admin mode is on (the token is inherited) or when no
|
||||
// standard user's token could be had; 07_IPC §C's owner check is what makes either reachable.
|
||||
Log.Information("agent: started {Path} {Arguments} (pid {Pid}{Elevated})", AgentPath, arguments, started.Id,
|
||||
Environment.IsPrivilegedProcess ? ", elevated like this App" : string.Empty);
|
||||
_lastStarted = WatchUntilExitAsync(started);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static async Task WatchUntilExitAsync(Process agent)
|
||||
/// <summary>Holds the marker until the elevated Agent claims the folder or exits; exit 11 is remembered for this App's life.</summary>
|
||||
private async Task WatchElevatedAsync(Process agent, ElevationMarker marker)
|
||||
{
|
||||
using (marker)
|
||||
{
|
||||
await AgentElevation.WaitForClaimAsync(agent, _dataDirectory, TimeSpan.FromMinutes(2)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
int? code = await WaitForExitCodeAsync(agent).ConfigureAwait(false);
|
||||
if (code == AgentElevation.ExitOtherAccount)
|
||||
{
|
||||
_otherAccountAnswered = true;
|
||||
Log.Warning("agent: the administrator prompt was answered with another account, whose Agent refused to run; "
|
||||
+ "until this App restarts the Agent starts as a standard user");
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task WatchUntilExitAsync(Process agent) => await WaitForExitCodeAsync(agent).ConfigureAwait(false);
|
||||
|
||||
private static async Task<int?> WaitForExitCodeAsync(Process agent)
|
||||
{
|
||||
using (agent)
|
||||
{
|
||||
int pid = agent.Id;
|
||||
await agent.WaitForExitAsync().ConfigureAwait(false);
|
||||
int code = agent.ExitCode;
|
||||
int? code;
|
||||
try
|
||||
{
|
||||
code = agent.ExitCode;
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or Win32Exception)
|
||||
{
|
||||
code = null;
|
||||
}
|
||||
|
||||
Log.Information("agent: pid {Pid} exited {Code}{Meaning}", pid, code,
|
||||
code == AgentInstanceLock.ExitHeldElsewhere ? " — another Agent already holds the data folder" : string.Empty);
|
||||
code == AgentInstanceLock.ExitHeldElsewhere ? " — another Agent already holds the data folder"
|
||||
: code == AgentElevation.ExitOtherAccount ? " — it ran as another account than this App's user"
|
||||
: string.Empty);
|
||||
return code;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,7 @@ public static class AgentStatusPresentation
|
||||
AgentConnectionState.Starting => (Strings.Agent_State_Starting, ControlAppearance.Info),
|
||||
AgentConnectionState.Offline => (Strings.Agent_State_Offline, ControlAppearance.Caution),
|
||||
AgentConnectionState.Missing => (Strings.Agent_State_Missing, ControlAppearance.Danger),
|
||||
AgentConnectionState.Elevating => (Strings.Agent_State_Elevating, ControlAppearance.Info),
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(state), state, "not a connection state"),
|
||||
};
|
||||
|
||||
|
||||
@@ -419,6 +419,7 @@ public static class Formats
|
||||
5 => Strings.Launch_Error_5,
|
||||
193 => Strings.Launch_Error_193,
|
||||
740 => Strings.Launch_Error_740,
|
||||
1400 => Strings.Launch_Error_1400,
|
||||
_ => string.Format(CultureInfo.CurrentCulture, Strings.Launch_Error_Format, error),
|
||||
};
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>
|
||||
/// The admin mode's disclosure as a question (beta.10, owner decision D34): shows the versioned text and answers whether the
|
||||
/// user understood and chose to have the Agent started as administrator. The WPF implementation is
|
||||
/// <see cref="AgentAdminPrompt"/>; a test substitutes an answer.
|
||||
/// </summary>
|
||||
public interface IAgentAdminPrompt
|
||||
{
|
||||
Task<bool> ShowAsync(CancellationToken ct = default);
|
||||
}
|
||||
@@ -17,6 +17,12 @@ public interface IAgentLauncher
|
||||
/// </summary>
|
||||
string? RunningAgent { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Whether <see cref="TryStart"/> would show Windows' administrator prompt (beta.10, the admin mode on and this App a
|
||||
/// standard user's) — the pill says so while the round waits for the answer. A launcher that never asks answers false.
|
||||
/// </summary>
|
||||
bool WillAskForElevation => false;
|
||||
|
||||
/// <summary>Start <c>FrameLedger.Agent.exe --serve</c>, detached; false when it could not be started.</summary>
|
||||
bool TryStart();
|
||||
}
|
||||
@@ -22,4 +22,9 @@ public interface IAgentLink : IAgentRequests
|
||||
/// apply asks the Agent to stop and must not have it restarted under the updater). Released on a failed apply.
|
||||
/// </summary>
|
||||
void SetLaunchHold(bool hold);
|
||||
|
||||
/// <summary>Skip the wait before the next connect round (the banner's Retry; the admin mode's restart, beta.10).</summary>
|
||||
void RetryNow()
|
||||
{
|
||||
}
|
||||
}
|
||||
@@ -19,6 +19,13 @@ public sealed class ShellHost(IServiceProvider services, INavigationService navi
|
||||
private MainWindow? _current;
|
||||
private Type _page = typeof(DashboardPage);
|
||||
private bool _exiting;
|
||||
private long _handle;
|
||||
|
||||
/// <summary>
|
||||
/// The live window's handle, for Windows' administrator prompt to belong to (beta.10, the admin mode); 0 before the first
|
||||
/// window. Written on the UI thread when a window is shown, read from the Agent connection's thread.
|
||||
/// </summary>
|
||||
public nint Handle => (nint)Interlocked.Read(ref _handle);
|
||||
|
||||
public void Show()
|
||||
{
|
||||
@@ -27,6 +34,7 @@ public sealed class ShellHost(IServiceProvider services, INavigationService navi
|
||||
window.Closed += OnClosed;
|
||||
_current = window;
|
||||
window.Show();
|
||||
Interlocked.Exchange(ref _handle, new System.Windows.Interop.WindowInteropHelper(window).Handle);
|
||||
navigation.Navigate(_page);
|
||||
// NFR-4 "cold start ≤ 2 s": measured from the process's own start, printed every run so a regression is a log line.
|
||||
Serilog.Log.Information("ui: shell shown {Ms} ms after process start", (long)(DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).TotalMilliseconds);
|
||||
|
||||
Generated
+30
@@ -42,6 +42,7 @@ public static class Strings
|
||||
nameof(Agent_Banner_Retry),
|
||||
nameof(Agent_State_Connected),
|
||||
nameof(Agent_State_Connecting),
|
||||
nameof(Agent_State_Elevating),
|
||||
nameof(Agent_State_Missing),
|
||||
nameof(Agent_State_Offline),
|
||||
nameof(Agent_State_Starting),
|
||||
@@ -478,6 +479,7 @@ public static class Strings
|
||||
nameof(Latency_P95),
|
||||
nameof(Latency_Series),
|
||||
nameof(Latency_Stats_Format),
|
||||
nameof(Launch_Error_1400),
|
||||
nameof(Launch_Error_193),
|
||||
nameof(Launch_Error_2),
|
||||
nameof(Launch_Error_3),
|
||||
@@ -638,8 +640,16 @@ public static class Strings
|
||||
nameof(Settings_Agent_Elevated),
|
||||
nameof(Settings_Agent_Elevation_Body),
|
||||
nameof(Settings_Agent_Elevation_Label),
|
||||
nameof(Settings_Agent_ElevationDeclined),
|
||||
nameof(Settings_Agent_ElevationFailed),
|
||||
nameof(Settings_Agent_ElevationOtherAccount),
|
||||
nameof(Settings_Agent_Header),
|
||||
nameof(Settings_Agent_NotElevated),
|
||||
nameof(Settings_Agent_RunElevated_AfterSession),
|
||||
nameof(Settings_Agent_RunElevated_Body),
|
||||
nameof(Settings_Agent_RunElevated_Label),
|
||||
nameof(Settings_Agent_RunElevated_NotStopped),
|
||||
nameof(Settings_Agent_RunElevated_Restarting),
|
||||
nameof(Settings_Agent_Task_Installed),
|
||||
nameof(Settings_Agent_Task_Label),
|
||||
nameof(Settings_Agent_Task_NotInstalled),
|
||||
@@ -901,6 +911,8 @@ public static class Strings
|
||||
|
||||
public static string Agent_State_Connecting => ResourceManager.GetString(nameof(Agent_State_Connecting), Culture) ?? nameof(Agent_State_Connecting);
|
||||
|
||||
public static string Agent_State_Elevating => ResourceManager.GetString(nameof(Agent_State_Elevating), Culture) ?? nameof(Agent_State_Elevating);
|
||||
|
||||
public static string Agent_State_Missing => ResourceManager.GetString(nameof(Agent_State_Missing), Culture) ?? nameof(Agent_State_Missing);
|
||||
|
||||
public static string Agent_State_Offline => ResourceManager.GetString(nameof(Agent_State_Offline), Culture) ?? nameof(Agent_State_Offline);
|
||||
@@ -1773,6 +1785,8 @@ public static class Strings
|
||||
|
||||
public static string Latency_Stats_Format => ResourceManager.GetString(nameof(Latency_Stats_Format), Culture) ?? nameof(Latency_Stats_Format);
|
||||
|
||||
public static string Launch_Error_1400 => ResourceManager.GetString(nameof(Launch_Error_1400), Culture) ?? nameof(Launch_Error_1400);
|
||||
|
||||
public static string Launch_Error_193 => ResourceManager.GetString(nameof(Launch_Error_193), Culture) ?? nameof(Launch_Error_193);
|
||||
|
||||
public static string Launch_Error_2 => ResourceManager.GetString(nameof(Launch_Error_2), Culture) ?? nameof(Launch_Error_2);
|
||||
@@ -2093,10 +2107,26 @@ public static class Strings
|
||||
|
||||
public static string Settings_Agent_Elevation_Label => ResourceManager.GetString(nameof(Settings_Agent_Elevation_Label), Culture) ?? nameof(Settings_Agent_Elevation_Label);
|
||||
|
||||
public static string Settings_Agent_ElevationDeclined => ResourceManager.GetString(nameof(Settings_Agent_ElevationDeclined), Culture) ?? nameof(Settings_Agent_ElevationDeclined);
|
||||
|
||||
public static string Settings_Agent_ElevationFailed => ResourceManager.GetString(nameof(Settings_Agent_ElevationFailed), Culture) ?? nameof(Settings_Agent_ElevationFailed);
|
||||
|
||||
public static string Settings_Agent_ElevationOtherAccount => ResourceManager.GetString(nameof(Settings_Agent_ElevationOtherAccount), Culture) ?? nameof(Settings_Agent_ElevationOtherAccount);
|
||||
|
||||
public static string Settings_Agent_Header => ResourceManager.GetString(nameof(Settings_Agent_Header), Culture) ?? nameof(Settings_Agent_Header);
|
||||
|
||||
public static string Settings_Agent_NotElevated => ResourceManager.GetString(nameof(Settings_Agent_NotElevated), Culture) ?? nameof(Settings_Agent_NotElevated);
|
||||
|
||||
public static string Settings_Agent_RunElevated_AfterSession => ResourceManager.GetString(nameof(Settings_Agent_RunElevated_AfterSession), Culture) ?? nameof(Settings_Agent_RunElevated_AfterSession);
|
||||
|
||||
public static string Settings_Agent_RunElevated_Body => ResourceManager.GetString(nameof(Settings_Agent_RunElevated_Body), Culture) ?? nameof(Settings_Agent_RunElevated_Body);
|
||||
|
||||
public static string Settings_Agent_RunElevated_Label => ResourceManager.GetString(nameof(Settings_Agent_RunElevated_Label), Culture) ?? nameof(Settings_Agent_RunElevated_Label);
|
||||
|
||||
public static string Settings_Agent_RunElevated_NotStopped => ResourceManager.GetString(nameof(Settings_Agent_RunElevated_NotStopped), Culture) ?? nameof(Settings_Agent_RunElevated_NotStopped);
|
||||
|
||||
public static string Settings_Agent_RunElevated_Restarting => ResourceManager.GetString(nameof(Settings_Agent_RunElevated_Restarting), Culture) ?? nameof(Settings_Agent_RunElevated_Restarting);
|
||||
|
||||
public static string Settings_Agent_Task_Installed => ResourceManager.GetString(nameof(Settings_Agent_Task_Installed), Culture) ?? nameof(Settings_Agent_Task_Installed);
|
||||
|
||||
public static string Settings_Agent_Task_Label => ResourceManager.GetString(nameof(Settings_Agent_Task_Label), Culture) ?? nameof(Settings_Agent_Task_Label);
|
||||
|
||||
@@ -61,6 +61,10 @@
|
||||
<value>エージェントを起動中…</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Agent_State_Elevating" xml:space="preserve">
|
||||
<value>管理者の許可を待っています…</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="App_Title" xml:space="preserve">
|
||||
<value>FrameLedger</value>
|
||||
<comment>review</comment>
|
||||
@@ -1745,6 +1749,38 @@
|
||||
<value>標準ユーザーとして実行中です。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Label" xml:space="preserve">
|
||||
<value>エージェントを管理者として実行</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Body" xml:space="preserve">
|
||||
<value>既定ではオフです。オンにすると、ログオン時を含め、エージェントが起動するたびに Windows が確認します。FrameLedger から起動したゲームは引き続き標準ユーザーの権限で実行されます。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationDeclined" xml:space="preserve">
|
||||
<value>標準ユーザーとして実行中です: 管理者の確認が拒否されました。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationOtherAccount" xml:space="preserve">
|
||||
<value>標準ユーザーとして実行中です: 別のアカウントで確認に応答されました。そのアカウントのエージェントはあなたのデータを使いません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationFailed" xml:space="preserve">
|
||||
<value>標準ユーザーとして実行中です: Windows はエージェントを管理者として起動できませんでした。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Restarting" xml:space="preserve">
|
||||
<value>保存しました。エージェントを再起動します。オプションがオンの場合は Windows が許可を求めます。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_AfterSession" xml:space="preserve">
|
||||
<value>保存しました。セッションが実行中のため、次に起動するまでエージェントは現在の権限のままです。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_NotStopped" xml:space="preserve">
|
||||
<value>保存しましたが、エージェントが停止しませんでした。次に起動するまで現在の権限のままです。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Settings_Agent_Task_Label" xml:space="preserve">
|
||||
<value>ログオン時にエージェントを起動</value>
|
||||
<comment>review</comment>
|
||||
@@ -3165,6 +3201,10 @@
|
||||
<value>ゲームには管理者権限が必要です</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Launch_Error_1400" xml:space="preserve">
|
||||
<value>標準ユーザーの権限でゲームを起動するためのデスクトップ シェルがありません (エージェントは管理者として実行されており、その方法でゲームを起動することはありません)</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Launch_Failed_Format" xml:space="preserve">
|
||||
<value>{0}({1})</value>
|
||||
<comment>review</comment>
|
||||
|
||||
@@ -51,6 +51,9 @@
|
||||
<data name="Agent_State_Starting" xml:space="preserve">
|
||||
<value>Starting agent…</value>
|
||||
</data>
|
||||
<data name="Agent_State_Elevating" xml:space="preserve">
|
||||
<value>Waiting for administrator permission…</value>
|
||||
</data>
|
||||
<data name="App_Title" xml:space="preserve">
|
||||
<value>FrameLedger</value>
|
||||
</data>
|
||||
@@ -1314,6 +1317,30 @@
|
||||
<data name="Settings_Agent_NotElevated" xml:space="preserve">
|
||||
<value>Running as a standard user.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Label" xml:space="preserve">
|
||||
<value>Run the agent as administrator</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Body" xml:space="preserve">
|
||||
<value>Off by default. When on, Windows asks every time the agent starts, at logon too. Games you start from FrameLedger still run with your standard rights.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationDeclined" xml:space="preserve">
|
||||
<value>Running as a standard user: the administrator prompt was declined.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationOtherAccount" xml:space="preserve">
|
||||
<value>Running as a standard user: the prompt was answered with another account, and that account's agent does not use your data.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationFailed" xml:space="preserve">
|
||||
<value>Running as a standard user: Windows could not start the agent as administrator.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Restarting" xml:space="preserve">
|
||||
<value>Saved. The agent restarts now; with the option on, Windows asks for permission.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_AfterSession" xml:space="preserve">
|
||||
<value>Saved. A session is running, so the agent keeps its current rights until it next starts.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_NotStopped" xml:space="preserve">
|
||||
<value>Saved, but the agent did not stop; it keeps its current rights until it next starts.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_Task_Label" xml:space="preserve">
|
||||
<value>Start the agent at logon</value>
|
||||
</data>
|
||||
@@ -2384,6 +2411,9 @@ The documents below are the full terms; this summary does not replace them.</val
|
||||
<data name="Launch_Error_740" xml:space="preserve">
|
||||
<value>the game requires administrator rights</value>
|
||||
</data>
|
||||
<data name="Launch_Error_1400" xml:space="preserve">
|
||||
<value>there is no desktop shell to start the game with a standard user's rights (the agent runs as administrator, and never starts a game that way)</value>
|
||||
</data>
|
||||
<data name="Launch_Failed_Format" xml:space="preserve">
|
||||
<value>{0} ({1})</value>
|
||||
</data>
|
||||
|
||||
@@ -46,6 +46,9 @@
|
||||
<data name="Agent_State_Starting" xml:space="preserve">
|
||||
<value>Đang khởi động agent…</value>
|
||||
</data>
|
||||
<data name="Agent_State_Elevating" xml:space="preserve">
|
||||
<value>Đang chờ quyền quản trị…</value>
|
||||
</data>
|
||||
<data name="App_Title" xml:space="preserve">
|
||||
<value>FrameLedger</value>
|
||||
</data>
|
||||
@@ -1309,6 +1312,30 @@
|
||||
<data name="Settings_Agent_NotElevated" xml:space="preserve">
|
||||
<value>Đang chạy với quyền người dùng thường.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Label" xml:space="preserve">
|
||||
<value>Chạy agent với quyền quản trị</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Body" xml:space="preserve">
|
||||
<value>Mặc định tắt. Khi bật, Windows sẽ hỏi mỗi lần agent khởi động, kể cả lúc đăng nhập. Game bạn khởi động từ FrameLedger vẫn chạy với quyền người dùng thường.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationDeclined" xml:space="preserve">
|
||||
<value>Đang chạy với quyền người dùng thường: hộp thoại quyền quản trị đã bị từ chối.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationOtherAccount" xml:space="preserve">
|
||||
<value>Đang chạy với quyền người dùng thường: hộp thoại được trả lời bằng một tài khoản khác, và agent của tài khoản đó không dùng dữ liệu của bạn.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_ElevationFailed" xml:space="preserve">
|
||||
<value>Đang chạy với quyền người dùng thường: Windows không thể khởi động agent với quyền quản trị.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_Restarting" xml:space="preserve">
|
||||
<value>Đã lưu. Agent đang khởi động lại; khi tuỳ chọn bật, Windows sẽ hỏi quyền.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_AfterSession" xml:space="preserve">
|
||||
<value>Đã lưu. Một phiên đang chạy, nên agent giữ quyền hiện tại cho đến lần khởi động sau.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_RunElevated_NotStopped" xml:space="preserve">
|
||||
<value>Đã lưu, nhưng agent không dừng; nó giữ quyền hiện tại cho đến lần khởi động sau.</value>
|
||||
</data>
|
||||
<data name="Settings_Agent_Task_Label" xml:space="preserve">
|
||||
<value>Khởi động agent khi đăng nhập</value>
|
||||
</data>
|
||||
@@ -2379,6 +2406,9 @@ Các tài liệu bên dưới là điều khoản đầy đủ; phần tóm tắ
|
||||
<data name="Launch_Error_740" xml:space="preserve">
|
||||
<value>game yêu cầu quyền quản trị</value>
|
||||
</data>
|
||||
<data name="Launch_Error_1400" xml:space="preserve">
|
||||
<value>không có desktop shell để khởi động game với quyền người dùng thường (agent đang chạy với quyền quản trị, và không bao giờ khởi động game theo cách đó)</value>
|
||||
</data>
|
||||
<data name="Launch_Failed_Format" xml:space="preserve">
|
||||
<value>{0} ({1})</value>
|
||||
</data>
|
||||
|
||||
@@ -22,6 +22,7 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
|
||||
private static readonly TimeSpan _defaultAgentStopTimeout = TimeSpan.FromSeconds(10);
|
||||
|
||||
private readonly TimeSpan _agentStopTimeout;
|
||||
private readonly Func<bool> _agentHeld;
|
||||
private readonly IUpdateClient _client;
|
||||
private readonly IAgentLink _agent;
|
||||
private readonly RegisteredSettings _settings;
|
||||
@@ -42,12 +43,15 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
|
||||
private int _percent;
|
||||
|
||||
/// <summary>
|
||||
/// The flow over its ports; subscribes to the Agent link for the session facts FR-12 needs. The last parameter is
|
||||
/// how long the apply waits for the pipe to drop after <c>Shutdown</c> (10 s), overridable as a test's clock.
|
||||
/// The flow over its ports; subscribes to the Agent link for the session facts FR-12 needs. <paramref name="agentStopTimeout"/>
|
||||
/// is how long the apply waits for the Agent to stop after <c>Shutdown</c> (10 s), overridable as a test's clock;
|
||||
/// <paramref name="agentHeld"/> is whether an Agent process still holds the data folder (the instance lock), a test's own.
|
||||
/// </summary>
|
||||
public UpdateService(IUpdateClient client, IAgentLink agent, RegisteredSettings settings, IUpdatePrompts prompts, IShellPresence shell, IMessageStrip strip, TimeSpan? agentStopTimeout = null)
|
||||
public UpdateService(IUpdateClient client, IAgentLink agent, RegisteredSettings settings, IUpdatePrompts prompts, IShellPresence shell, IMessageStrip strip,
|
||||
TimeSpan? agentStopTimeout = null, Func<bool>? agentHeld = null)
|
||||
{
|
||||
_agentStopTimeout = agentStopTimeout ?? _defaultAgentStopTimeout;
|
||||
_agentHeld = agentHeld ?? (static () => Infrastructure.Startup.AgentInstanceLock.IsHeld(Services.UiPaths.DataDirectory));
|
||||
_client = client ?? throw new ArgumentNullException(nameof(client));
|
||||
_agent = agent ?? throw new ArgumentNullException(nameof(agent));
|
||||
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
|
||||
@@ -268,11 +272,17 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
|
||||
Stage = IsSessionActive ? UpdateStage.Deferred : UpdateStage.Ready;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The Agent stopped, or none was running: the pipe has dropped AND no process holds the data folder any more. Since
|
||||
/// beta.10 the second half matters — an Agent run as administrator (the admin mode) holds the install directory's files
|
||||
/// exactly as long as its process lives, and one that holds the folder without answering this App (still starting,
|
||||
/// another version) must not have the files replaced under it.
|
||||
/// </summary>
|
||||
private async Task<bool> StopAgentAsync(CancellationToken ct)
|
||||
{
|
||||
if (!_agent.IsConnected)
|
||||
{
|
||||
return true;
|
||||
return !_agentHeld();
|
||||
}
|
||||
|
||||
try
|
||||
@@ -285,7 +295,7 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
|
||||
}
|
||||
|
||||
DateTimeOffset deadline = DateTimeOffset.UtcNow + _agentStopTimeout;
|
||||
while (_agent.IsConnected)
|
||||
while (_agent.IsConnected || _agentHeld())
|
||||
{
|
||||
if (DateTimeOffset.UtcNow >= deadline)
|
||||
{
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
using CommunityToolkit.Mvvm.ComponentModel;
|
||||
using FrameLedger.Shared.Safety;
|
||||
using SafetyStrings = FrameLedger.Shared.Strings;
|
||||
|
||||
namespace FrameLedger.App.ViewModels;
|
||||
|
||||
/// <summary>
|
||||
/// The admin mode's disclosure (beta.10, owner decision D34; <c>19_SAFETY</c> §Elevated targets): what running the Agent as
|
||||
/// administrator adds, what it does not change, how Windows asks, and the risk of a per-user install. <see cref="Accepted"/>
|
||||
/// — the user ticking that they understand — is the one thing that enables the dialog's primary button.
|
||||
/// </summary>
|
||||
public sealed partial class AgentAdminDialogViewModel : ObservableObject
|
||||
{
|
||||
[ObservableProperty]
|
||||
private bool _accepted;
|
||||
|
||||
public static string Title => SafetyStrings.Safety_AdminMode_Title;
|
||||
|
||||
public static string Intro => SafetyStrings.Safety_AdminMode_Intro;
|
||||
|
||||
public static string Adds => SafetyStrings.Safety_AdminMode_Adds;
|
||||
|
||||
public static string Unchanged => SafetyStrings.Safety_AdminMode_Unchanged;
|
||||
|
||||
public static string Prompt => SafetyStrings.Safety_AdminMode_Prompt;
|
||||
|
||||
public static string Risk => SafetyStrings.Safety_AdminMode_Risk;
|
||||
|
||||
public static string AcceptText => SafetyStrings.Safety_AdminMode_Accept;
|
||||
|
||||
public static string TurnOnText => SafetyStrings.Safety_AdminMode_TurnOn;
|
||||
|
||||
public static string CancelText => SafetyStrings.Safety_AdminMode_Cancel;
|
||||
|
||||
/// <summary>The version of the text shown, in the dialog's corner, as FR-2.1's dialog shows its own.</summary>
|
||||
public static string Version => AgentAdminDisclosure.Version;
|
||||
}
|
||||
@@ -8,7 +8,9 @@ using CommunityToolkit.Mvvm.Input;
|
||||
using FrameLedger.App.Services;
|
||||
using FrameLedger.Application.Persistence;
|
||||
using FrameLedger.Application.Settings;
|
||||
using FrameLedger.Infrastructure.Ipc;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using FrameLedger.Shared.Ipc;
|
||||
|
||||
namespace FrameLedger.App.ViewModels;
|
||||
|
||||
@@ -40,8 +42,17 @@ public sealed partial class SettingsViewModel : ObservableObject
|
||||
private readonly WindowClosePolicy _closePolicy;
|
||||
private readonly IFirstRunFlow _firstRun;
|
||||
private readonly AntiCheatExceptions? _exceptions;
|
||||
private readonly IAgentAdminPrompt? _adminPrompt;
|
||||
private readonly Func<bool> _agentHeld;
|
||||
private bool _loading = true;
|
||||
|
||||
/// <summary>
|
||||
/// <c>capture.run_elevated</c> (beta.10, owner decision D34): the Agent is started as administrator — Windows asks at every
|
||||
/// start. Turning it on shows the disclosure first; either way the Agent restarts when no session is running.
|
||||
/// </summary>
|
||||
[ObservableProperty]
|
||||
private bool _runElevated;
|
||||
|
||||
[ObservableProperty]
|
||||
private AppTheme _selectedTheme;
|
||||
|
||||
@@ -134,8 +145,14 @@ public sealed partial class SettingsViewModel : ObservableObject
|
||||
IAgentTool tool,
|
||||
WindowClosePolicy closePolicy,
|
||||
IFirstRunFlow firstRun,
|
||||
AntiCheatExceptions? exceptions = null)
|
||||
AntiCheatExceptions? exceptions = null,
|
||||
IAgentAdminPrompt? adminPrompt = null,
|
||||
Func<bool>? agentHeld = null)
|
||||
{
|
||||
// The admin mode's disclosure (a composition without it — a test — cannot turn the mode on), and the probe of the
|
||||
// data folder's instance lock the restart waits on (a test's own).
|
||||
_adminPrompt = adminPrompt;
|
||||
_agentHeld = agentHeld ?? (static () => AgentInstanceLock.IsHeld(UiPaths.DataDirectory));
|
||||
// D33: the user-mode exception's requests; a composition without it (a test) answers that the Agent is unavailable.
|
||||
_exceptions = exceptions;
|
||||
_firstRun = firstRun ?? throw new ArgumentNullException(nameof(firstRun));
|
||||
@@ -249,6 +266,78 @@ public sealed partial class SettingsViewModel : ObservableObject
|
||||
|
||||
partial void OnKillSwitchChanged(bool value) => Persist(SettingsRegistry.HookingKillSwitch, value);
|
||||
|
||||
partial void OnRunElevatedChanged(bool value)
|
||||
{
|
||||
if (!_loading)
|
||||
{
|
||||
Pending = ApplyRunElevatedAsync(value);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>On: the disclosure, and nothing is written unless it is accepted. Then the row, then the Agent's restart.</summary>
|
||||
private async Task ApplyRunElevatedAsync(bool value)
|
||||
{
|
||||
if (value && (_adminPrompt is null || !await _adminPrompt.ShowAsync().ConfigureAwait(true)))
|
||||
{
|
||||
_loading = true;
|
||||
try
|
||||
{
|
||||
RunElevated = false;
|
||||
}
|
||||
finally
|
||||
{
|
||||
_loading = false;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
await _settings.SetAsync(SettingsRegistry.CaptureRunElevated, value ? "1" : "0").ConfigureAwait(true);
|
||||
await RestartAgentAsync().ConfigureAwait(true);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The mode is decided when the Agent starts, so it restarts — never under a running session, which the Shutdown would
|
||||
/// end. It is asked to stop over the pipe, its folder's instance lock is waited out (the process has gone), and the
|
||||
/// connection's next round starts it the new way.
|
||||
/// </summary>
|
||||
private async Task RestartAgentAsync()
|
||||
{
|
||||
string label = Strings.Settings_Agent_RunElevated_Label;
|
||||
if (_agent.Status?.ActiveSessions is { Count: > 0 })
|
||||
{
|
||||
_strip.Info(label, Strings.Settings_Agent_RunElevated_AfterSession);
|
||||
return;
|
||||
}
|
||||
|
||||
if (_agent.IsConnected)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _agent.RequestAsync(IpcMessageType.Shutdown, new ShutdownRequest()).ConfigureAwait(true);
|
||||
}
|
||||
catch (Exception ex) when (ex is IpcRequestException or TimeoutException or IOException or InvalidOperationException)
|
||||
{
|
||||
Serilog.Log.Warning(ex, "settings: the Agent did not acknowledge Shutdown for the admin mode's restart");
|
||||
}
|
||||
}
|
||||
|
||||
DateTimeOffset deadline = DateTimeOffset.UtcNow + TimeSpan.FromSeconds(20);
|
||||
while (_agentHeld() && DateTimeOffset.UtcNow < deadline)
|
||||
{
|
||||
await Task.Delay(200).ConfigureAwait(true);
|
||||
}
|
||||
|
||||
if (_agentHeld())
|
||||
{
|
||||
_strip.Warn(label, Strings.Settings_Agent_RunElevated_NotStopped);
|
||||
return;
|
||||
}
|
||||
|
||||
_agent.RetryNow();
|
||||
_strip.Info(label, Strings.Settings_Agent_RunElevated_Restarting);
|
||||
}
|
||||
|
||||
partial void OnMinSessionSecondsChanged(int oldValue, int newValue) => PersistNumber(SettingsRegistry.CaptureMinSessionSeconds, Strings.Settings_MinSession_Label, oldValue, newValue, v => MinSessionSeconds = v);
|
||||
|
||||
partial void OnTelemetryIntervalMsChanged(int oldValue, int newValue) => PersistNumber(SettingsRegistry.TelemetryIntervalMs, Strings.Settings_Interval_Label, oldValue, newValue, v => TelemetryIntervalMs = v);
|
||||
@@ -397,6 +486,7 @@ public sealed partial class SettingsViewModel : ObservableObject
|
||||
MinimizeToTray = await _settings.GetBooleanAsync(SettingsRegistry.UiMinimizeToTray).ConfigureAwait(true);
|
||||
HideAntiCheatHooking = await _settings.GetBooleanAsync(SettingsRegistry.UiHideAntiCheatHooking).ConfigureAwait(true);
|
||||
UserModeExceptions = await _settings.GetBooleanAsync(SettingsRegistry.HookingUserModeExceptions).ConfigureAwait(true);
|
||||
RunElevated = await _settings.GetBooleanAsync(SettingsRegistry.CaptureRunElevated).ConfigureAwait(true);
|
||||
FpsTwoDecimals = await _settings.GetBooleanAsync(SettingsRegistry.UiFpsDecimals).ConfigureAwait(true);
|
||||
OnlineMetadata = await _settings.GetBooleanAsync(SettingsRegistry.PrivacyOnlineMetadata).ConfigureAwait(true);
|
||||
UpdateChannel = await _settings.GetAsync(SettingsRegistry.UpdateChannel).ConfigureAwait(true);
|
||||
@@ -425,11 +515,25 @@ public sealed partial class SettingsViewModel : ObservableObject
|
||||
PresentExceptions(cards);
|
||||
|
||||
Shared.Ipc.HelloAck? hello = _agent.Hello;
|
||||
ElevationText = hello is null ? Strings.Settings_VkLayer_Unknown : hello.Elevated ? Strings.Settings_Agent_Elevated : Strings.Settings_Agent_NotElevated;
|
||||
ElevationText = ElevationTextOf(_agent.State, hello);
|
||||
MaintenanceSnapshot = await _maintenance.ReadAsync().ConfigureAwait(true);
|
||||
OnPropertyChanged(nameof(CanRegisterLayer));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// What the Agent's rights are, and — beta.10 — why a standard user's Agent is one when the admin mode asked Windows and
|
||||
/// was not granted (<c>HelloAck.ElevationOutcome</c>).
|
||||
/// </summary>
|
||||
internal static string ElevationTextOf(AgentConnectionState state, HelloAck? hello) => hello switch
|
||||
{
|
||||
null => state == AgentConnectionState.Elevating ? Strings.Agent_State_Elevating : Strings.Settings_VkLayer_Unknown,
|
||||
{ Elevated: true } => Strings.Settings_Agent_Elevated,
|
||||
{ ElevationOutcome: AgentElevation.Declined } => Strings.Settings_Agent_ElevationDeclined,
|
||||
{ ElevationOutcome: AgentElevation.OtherAccount } => Strings.Settings_Agent_ElevationOtherAccount,
|
||||
{ ElevationOutcome: AgentElevation.Failed } => Strings.Settings_Agent_ElevationFailed,
|
||||
_ => Strings.Settings_Agent_NotElevated,
|
||||
};
|
||||
|
||||
private async Task RunToolAsync(string flag, string label)
|
||||
{
|
||||
IsToolRunning = true;
|
||||
|
||||
@@ -12,6 +12,10 @@ namespace FrameLedger.Application.Ipc;
|
||||
/// <param name="CpuTempAvailable">False until the Agent composes a CPU sensor (LHM's CPU half is off unelevated).</param>
|
||||
/// <param name="DisclosureVersion">The FR-2.1 disclosure this Agent stamps against (<c>Shared.Safety.SafetyDisclosure.Version</c> under <c>--serve</c>; null on a composition that carries none) — D14, P3 PR-4.</param>
|
||||
/// <param name="ExceptionDisclosureVersion">D33: the user-mode exception's disclosure this Agent grants against (<c>Shared.Safety.AntiCheatExceptionDisclosure.Version</c> under <c>--serve</c>; null where none is carried).</param>
|
||||
/// <param name="ElevationOutcome">
|
||||
/// The admin mode's answer at this Agent's start (beta.10, D34; <c>Infrastructure.Startup.AgentElevation</c>): <c>granted</c>,
|
||||
/// <c>declined</c>, <c>other-account</c> or <c>failed</c>; null when nobody asked — the option off, or elevation inherited.
|
||||
/// </param>
|
||||
public sealed record AgentIdentity(
|
||||
string AgentVersion,
|
||||
int Pid,
|
||||
@@ -20,4 +24,5 @@ public sealed record AgentIdentity(
|
||||
bool VulkanLayerRegistered,
|
||||
bool CpuTempAvailable,
|
||||
string? DisclosureVersion = null,
|
||||
string? ExceptionDisclosureVersion = null);
|
||||
string? ExceptionDisclosureVersion = null,
|
||||
string? ElevationOutcome = null);
|
||||
@@ -69,7 +69,8 @@ public sealed class AgentRequestHandler : IIpcRequestHandler
|
||||
Descriptor(),
|
||||
_identity.CpuTempAvailable,
|
||||
_identity.DisclosureVersion,
|
||||
_identity.ExceptionDisclosureVersion));
|
||||
_identity.ExceptionDisclosureVersion,
|
||||
_identity.ElevationOutcome));
|
||||
}
|
||||
|
||||
/// <summary>Null when the layers cannot be composed at all — an absent descriptor, never an invented one.</summary>
|
||||
|
||||
@@ -94,6 +94,21 @@ public static class SettingsRegistry
|
||||
AgentReads = true,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// The Agent's admin mode (beta.10, owner decision D34; ADR-9): whether the Agent is started as administrator — Windows
|
||||
/// asks, a UAC prompt, every time it starts, whoever starts it. Off by default. Read before the Agent exists, by the App
|
||||
/// and by an Agent the logon task started (<c>Infrastructure.Startup.RunElevatedSetting</c>, which names the same key);
|
||||
/// exactly "1" is on. It unlocks attaching to games that run as administrator and the CPU temperature (with PawnIO); it
|
||||
/// never lets a game started from FrameLedger run elevated.
|
||||
/// </summary>
|
||||
public static readonly SettingDefinition CaptureRunElevated = new()
|
||||
{
|
||||
Key = "capture.run_elevated",
|
||||
Kind = SettingKind.Boolean,
|
||||
Default = "0",
|
||||
AgentReads = true,
|
||||
};
|
||||
|
||||
/// <summary>FR-3.6: sessions shorter than this are discarded. Seconds.</summary>
|
||||
public static readonly SettingDefinition CaptureMinSessionSeconds = new()
|
||||
{
|
||||
@@ -164,7 +179,7 @@ public static class SettingsRegistry
|
||||
public static IReadOnlyList<SettingDefinition> All { get; } =
|
||||
[
|
||||
UiLanguage, UiTheme, UiStartWithWindows, UiMinimizeToTray, UiHideAntiCheatHooking, UiFpsDecimals,
|
||||
CaptureBackground, HookingKillSwitch, HookingUserModeExceptions, CaptureMinSessionSeconds, TelemetryIntervalMs, RetentionRawSessionsPerGame,
|
||||
CaptureBackground, HookingKillSwitch, HookingUserModeExceptions, CaptureRunElevated, CaptureMinSessionSeconds, TelemetryIntervalMs, RetentionRawSessionsPerGame,
|
||||
UpdateChannel, UpdateAutoCheck, PrivacyOnlineMetadata, LogDebug,
|
||||
];
|
||||
|
||||
|
||||
@@ -2,6 +2,7 @@ using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using FrameLedger.Application.Capture;
|
||||
using FrameLedger.Infrastructure.Io;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using FrameLedger.Infrastructure.Vulkan;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Capture;
|
||||
@@ -27,6 +28,12 @@ namespace FrameLedger.Infrastructure.Capture;
|
||||
/// product's Tier 2 does (duration and the reason, no measurement). The operator asked for the game to
|
||||
/// start; the guard decides only whether FrameLedger goes into it.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>An elevated Agent never starts a game elevated</b> (beta.10, the Agent's admin mode, D34): the game gets the token the
|
||||
/// desktop shell runs with (<see cref="UnelevatedProcess"/>), which is what a double-click would give it — otherwise
|
||||
/// <c>LaunchGame</c>, which any process of the same user can send, would be an elevation without a prompt. When no shell
|
||||
/// token can be had the launch is refused with that reason, never made elevated instead.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class ProcessLauncher : IProcessLauncher
|
||||
{
|
||||
@@ -75,17 +82,29 @@ public sealed class ProcessLauncher : IProcessLauncher
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
|
||||
error = null;
|
||||
|
||||
var psi = new ProcessStartInfo(exePath, arguments ?? string.Empty)
|
||||
{
|
||||
UseShellExecute = false,
|
||||
WorkingDirectory = Path.GetDirectoryName(exePath) ?? string.Empty,
|
||||
};
|
||||
var variables = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||||
if (enableVulkanLayer)
|
||||
{
|
||||
psi.Environment[VkLayerLaunchEnvironment.EnableVariable] = "1";
|
||||
variables[VkLayerLaunchEnvironment.EnableVariable] = "1";
|
||||
}
|
||||
|
||||
foreach ((string name, string value) in environment ?? new Dictionary<string, string>(StringComparer.Ordinal))
|
||||
{
|
||||
variables[name] = value;
|
||||
}
|
||||
|
||||
string workingDirectory = Path.GetDirectoryName(exePath) ?? string.Empty;
|
||||
if (Environment.IsPrivilegedProcess)
|
||||
{
|
||||
return StartUnelevated(exePath, arguments ?? string.Empty, workingDirectory, variables, out error);
|
||||
}
|
||||
|
||||
var psi = new ProcessStartInfo(exePath, arguments ?? string.Empty)
|
||||
{
|
||||
UseShellExecute = false,
|
||||
WorkingDirectory = workingDirectory,
|
||||
};
|
||||
foreach ((string name, string value) in variables)
|
||||
{
|
||||
psi.Environment[name] = value;
|
||||
}
|
||||
@@ -108,26 +127,50 @@ public sealed class ProcessLauncher : IProcessLauncher
|
||||
|
||||
using (process)
|
||||
{
|
||||
// The same pin attach mode takes, taken here before anything else looks at the pid. The
|
||||
// liveness OWNS the handle from here; the caller disposes it with the session (CA2000 is
|
||||
// satisfied by that transfer, stated rather than suppressed).
|
||||
HeldProcessHandle? held = null;
|
||||
try
|
||||
{
|
||||
held = HeldProcessHandle.TryOpen(process.Id);
|
||||
if (held is null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return Pin(process.Id);
|
||||
}
|
||||
}
|
||||
|
||||
ITargetLiveness alive = new ProcessTargetLiveness(held, process.Id);
|
||||
held = null;
|
||||
return (process.Id, alive);
|
||||
}
|
||||
finally
|
||||
/// <summary>The start an elevated Agent makes: the shell's token, and the same pin, taken while the start's own handle still holds the id.</summary>
|
||||
private static (int Pid, ITargetLiveness Alive)? StartUnelevated(string exePath, string arguments, string workingDirectory,
|
||||
IReadOnlyDictionary<string, string> variables, out int? error)
|
||||
{
|
||||
error = null;
|
||||
(int Pid, IDisposable Process)? started = UnelevatedProcess.Start(exePath, arguments, workingDirectory, variables, out int failure);
|
||||
if (started is not { } s)
|
||||
{
|
||||
error = failure;
|
||||
return null;
|
||||
}
|
||||
|
||||
using (s.Process)
|
||||
{
|
||||
return Pin(s.Pid);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The same pin attach mode takes, taken before anything else looks at the pid. The liveness OWNS the handle from here; the
|
||||
/// caller disposes it with the session (CA2000 is satisfied by that transfer, stated rather than suppressed).
|
||||
/// </summary>
|
||||
private static (int Pid, ITargetLiveness Alive)? Pin(int pid)
|
||||
{
|
||||
HeldProcessHandle? held = null;
|
||||
try
|
||||
{
|
||||
held = HeldProcessHandle.TryOpen(pid);
|
||||
if (held is null)
|
||||
{
|
||||
held?.Dispose();
|
||||
return null;
|
||||
}
|
||||
|
||||
ITargetLiveness alive = new ProcessTargetLiveness(held, pid);
|
||||
held = null;
|
||||
return (pid, alive);
|
||||
}
|
||||
finally
|
||||
{
|
||||
held?.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -58,3 +58,24 @@ MONITORINFOEXW
|
||||
DwmGetWindowAttribute
|
||||
DWMWINDOWATTRIBUTE
|
||||
SetThreadDpiAwarenessContext
|
||||
// The Agent's admin mode (beta.10, owner decision D34; 01_ARCHITECTURE ADR-9). A game an elevated Agent starts gets the
|
||||
// token the desktop shell runs with, never the Agent's (Startup.UnelevatedProcess); a lock an elevated process creates
|
||||
// states a DACL the same user's unelevated processes can open (Startup.SharedMutex); and the token's enabled privileges
|
||||
// are read, never changed (Startup.TokenPrivileges) - nothing here adjusts a privilege (tools/chokepoint-check.ps1).
|
||||
GetShellWindow
|
||||
GetCurrentProcess
|
||||
OpenProcess
|
||||
OpenProcessToken
|
||||
DuplicateTokenEx
|
||||
CreateProcessWithTokenW
|
||||
STARTUPINFOW
|
||||
PROCESS_INFORMATION
|
||||
PROCESS_CREATION_FLAGS
|
||||
GetTokenInformation
|
||||
TOKEN_PRIVILEGES
|
||||
TOKEN_ELEVATION
|
||||
LookupPrivilegeName
|
||||
CreateMutex
|
||||
WaitForSingleObject
|
||||
ReleaseMutex
|
||||
CloseHandle
|
||||
@@ -3,6 +3,7 @@ using System.Reflection;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using Dapper;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using Microsoft.Data.Sqlite;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Persistence;
|
||||
@@ -67,19 +68,13 @@ public static class MigrationRunner
|
||||
|
||||
// The mutex serialises two processes opening the same file at once; the transaction below and
|
||||
// schema_migrations' primary key serialise the rest. Taken synchronously: this runs once, at open.
|
||||
using var mutex = new Mutex(initiallyOwned: false, LockNameFor(connection.DataSource));
|
||||
bool held = false;
|
||||
// Its DACL is stated (beta.10, the Agent's admin mode): an elevated Agent's default one would have locked the same
|
||||
// user's unelevated App out of it (Startup.SharedMutex).
|
||||
using SharedMutex mutex = SharedMutex.CreateOrOpen(LockNameFor(connection.DataSource));
|
||||
// An abandoned wait is the lock taken: the previous holder died mid-migration, and its transaction rolled back.
|
||||
bool held = mutex.Wait(TimeSpan.FromSeconds(30), out _);
|
||||
try
|
||||
{
|
||||
try
|
||||
{
|
||||
held = mutex.WaitOne(TimeSpan.FromSeconds(30));
|
||||
}
|
||||
catch (AbandonedMutexException)
|
||||
{
|
||||
held = true; // the previous holder died mid-migration; its transaction rolled back
|
||||
}
|
||||
|
||||
if (!held)
|
||||
{
|
||||
throw new TimeoutException("another process has been migrating the ledger for over 30 s");
|
||||
@@ -91,7 +86,7 @@ public static class MigrationRunner
|
||||
{
|
||||
if (held)
|
||||
{
|
||||
mutex.ReleaseMutex();
|
||||
mutex.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,143 @@
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using System.Security.Principal;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// The Agent's admin mode (beta.10, owner decision D34): Windows is asked — a UAC prompt — EVERY time the Agent starts while
|
||||
/// <c>capture.run_elevated</c> is on, by whoever starts it: the App (its own window owns the prompt) or an Agent the logon
|
||||
/// task started (the prompt flashes on the taskbar). There is no silent path: no "highest privileges" task, no service.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>The elevated Agent is told whose it is</b> (<c>--serve --for-user <SID></c>) and checks it before it touches
|
||||
/// anything: a standard user answers the prompt with an administrator's password, and the Agent that starts then runs as
|
||||
/// THAT account — its <c>%LOCALAPPDATA%</c> is someone else's ledger. It exits <see cref="ExitOtherAccount"/>, and the
|
||||
/// starter carries on with a standard user's Agent that says why.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>An Agent that was asked for and not granted says so</b> (<c>--serve --elevation <outcome></c>, and
|
||||
/// <c>HelloAck.ElevationOutcome</c>), and does not ask again: the answer was the user's.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class AgentElevation
|
||||
{
|
||||
/// <summary>The exit code of an elevated Agent whose token belongs to another account than the one that asked.</summary>
|
||||
public const int ExitOtherAccount = 11;
|
||||
|
||||
/// <summary><c>ERROR_CANCELLED</c>: the user answered the prompt No.</summary>
|
||||
public const int ErrorCancelled = 1223;
|
||||
|
||||
/// <summary>The prompt was accepted by the account that asked; this Agent is elevated.</summary>
|
||||
public const string Granted = "granted";
|
||||
|
||||
/// <summary>The prompt was answered No.</summary>
|
||||
public const string Declined = "declined";
|
||||
|
||||
/// <summary>The prompt was accepted with another account's credentials, whose Agent refused to run.</summary>
|
||||
public const string OtherAccount = "other-account";
|
||||
|
||||
/// <summary>Windows could not show the prompt or start the elevated Agent.</summary>
|
||||
public const string Failed = "failed";
|
||||
|
||||
/// <summary>The outcomes a starter may pass on the command line (<c>--elevation</c>).</summary>
|
||||
public static readonly IReadOnlyList<string> Refusals = [Declined, OtherAccount, Failed];
|
||||
|
||||
/// <summary>This process's token user, as the elevated Agent will compare it.</summary>
|
||||
public static string CurrentUserSid()
|
||||
{
|
||||
using WindowsIdentity identity = WindowsIdentity.GetCurrent();
|
||||
return identity.User?.Value ?? throw new InvalidOperationException("the current token carries no user SID");
|
||||
}
|
||||
|
||||
/// <summary>Whether <paramref name="sid"/> is this process's token user.</summary>
|
||||
public static bool IsCurrentUser(string sid)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(sid);
|
||||
return string.Equals(CurrentUserSid(), sid, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Asks Windows to start <paramref name="agentPath"/> elevated with <paramref name="arguments"/>: the UAC prompt, owned by
|
||||
/// <paramref name="ownerWindow"/> when there is one. Blocks while the prompt is up. The process, or null with
|
||||
/// <see cref="Declined"/> or <see cref="Failed"/> in <paramref name="refusal"/>.
|
||||
/// </summary>
|
||||
public static Process? Start(string agentPath, string arguments, nint ownerWindow, out string? refusal, out int? error)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(agentPath);
|
||||
refusal = null;
|
||||
error = null;
|
||||
try
|
||||
{
|
||||
Process? started = Process.Start(new ProcessStartInfo(agentPath, arguments ?? string.Empty)
|
||||
{
|
||||
UseShellExecute = true,
|
||||
Verb = "runas",
|
||||
WindowStyle = ProcessWindowStyle.Hidden,
|
||||
WorkingDirectory = Path.GetDirectoryName(agentPath) ?? string.Empty,
|
||||
// The window the prompt belongs to. ErrorDialog is what makes .NET pass it; a cancelled prompt shows no
|
||||
// error dialog, and a missing file is checked before this is ever called.
|
||||
ErrorDialog = ownerWindow != 0,
|
||||
ErrorDialogParentHandle = ownerWindow,
|
||||
});
|
||||
if (started is null)
|
||||
{
|
||||
refusal = Failed;
|
||||
}
|
||||
|
||||
return started;
|
||||
}
|
||||
catch (Win32Exception ex)
|
||||
{
|
||||
error = ex.NativeErrorCode;
|
||||
refusal = ex.NativeErrorCode == ErrorCancelled ? Declined : Failed;
|
||||
return null;
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or IOException)
|
||||
{
|
||||
refusal = Failed;
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Waits until the elevated Agent has claimed <paramref name="dataDirectory"/> (true) or has exited (false, with its code),
|
||||
/// up to <paramref name="timeout"/> (false, no code: it neither claimed nor exited).
|
||||
/// </summary>
|
||||
public static async Task<(bool Claimed, int? ExitCode)> WaitForClaimAsync(Process agent, string dataDirectory, TimeSpan timeout,
|
||||
CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(agent);
|
||||
DateTimeOffset deadline = DateTimeOffset.UtcNow + timeout;
|
||||
while (DateTimeOffset.UtcNow < deadline)
|
||||
{
|
||||
if (AgentInstanceLock.IsHeld(dataDirectory))
|
||||
{
|
||||
return (true, null);
|
||||
}
|
||||
|
||||
if (agent.HasExited)
|
||||
{
|
||||
// The claim may have come and gone with a short-lived Agent; the exit code says which.
|
||||
return (false, SafeExitCode(agent));
|
||||
}
|
||||
|
||||
await Task.Delay(100, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return (AgentInstanceLock.IsHeld(dataDirectory), null);
|
||||
}
|
||||
|
||||
private static int? SafeExitCode(Process agent)
|
||||
{
|
||||
try
|
||||
{
|
||||
return agent.ExitCode;
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or Win32Exception)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// "An Agent is being started as administrator right now" (beta.10, the Agent's admin mode, owner decision D34): a named
|
||||
/// mutex beside the data folder's <see cref="AgentInstanceLock"/>, held by whoever shows the UAC prompt — the App starting
|
||||
/// the Agent, or an Agent the logon task started — until the elevated Agent has claimed the folder or has exited.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The App's launcher and a starting Agent both read it as "an Agent is coming": without it, the App at logon would find no
|
||||
/// Agent while the task's prompt is still on the taskbar, start its own, and prompt a second time — two prompts, and two
|
||||
/// Agents if both were accepted. Held, never waited on, released with its handle, exactly as the instance lock is.
|
||||
/// </remarks>
|
||||
public sealed class ElevationMarker : IDisposable
|
||||
{
|
||||
private readonly Mutex _mutex;
|
||||
|
||||
private ElevationMarker(Mutex mutex) => _mutex = mutex;
|
||||
|
||||
/// <summary><c>Local\FrameLedger.Agent.Elevating.<32 hex digits></c> — the instance lock's key, its own name.</summary>
|
||||
public static string NameFor(string dataDirectory) =>
|
||||
AgentInstanceLock.NameFor(dataDirectory).Replace(@"Local\FrameLedger.Agent.", @"Local\FrameLedger.Agent.Elevating.", StringComparison.Ordinal);
|
||||
|
||||
/// <summary>The marker for <paramref name="dataDirectory"/>, or null when another process already holds it.</summary>
|
||||
public static ElevationMarker? TryAcquire(string dataDirectory)
|
||||
{
|
||||
Mutex? mutex = null;
|
||||
try
|
||||
{
|
||||
mutex = new Mutex(initiallyOwned: false, NameFor(dataDirectory), out bool createdNew);
|
||||
if (!createdNew)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var marker = new ElevationMarker(mutex);
|
||||
mutex = null;
|
||||
return marker;
|
||||
}
|
||||
catch (Exception ex) when (ex is UnauthorizedAccessException or WaitHandleCannotBeOpenedException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
finally
|
||||
{
|
||||
mutex?.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>True while any process, this one included, holds the marker for <paramref name="dataDirectory"/>.</summary>
|
||||
public static bool IsHeld(string dataDirectory)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!Mutex.TryOpenExisting(NameFor(dataDirectory), out Mutex? existing))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
existing.Dispose();
|
||||
return true;
|
||||
}
|
||||
catch (UnauthorizedAccessException)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose() => _mutex.Dispose();
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
using Microsoft.Data.Sqlite;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// Whether the user turned on the Agent's admin mode (<c>capture.run_elevated</c>, beta.10, owner decision D34), read BEFORE
|
||||
/// the Agent starts or claims anything: by the App deciding how to start it, and by an Agent the logon task started deciding
|
||||
/// whether to ask Windows for elevation.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Not through <see cref="Persistence.LedgerDatabase"/>.</b> Its open migrates, or — read-only — refuses a ledger at
|
||||
/// another schema; the first start after an update meets exactly that ledger, and the answer here must not depend on who
|
||||
/// migrates first. One query on one row, <c>PRAGMA query_only</c>, nothing written.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Everything that is not an explicit "1" is off</b> — no ledger yet, no settings table, a locked or unreadable file: the
|
||||
/// Agent then starts as it always did, with a standard user's rights. Off is the default the owner chose.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class RunElevatedSetting
|
||||
{
|
||||
/// <summary>The registry key (<c>Application.Settings.SettingsRegistry.CaptureRunElevated</c>).</summary>
|
||||
public const string Key = "capture.run_elevated";
|
||||
|
||||
/// <summary>True only when the ledger at <paramref name="databasePath"/> says exactly "1".</summary>
|
||||
public static bool Read(string databasePath)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(databasePath);
|
||||
if (!File.Exists(databasePath))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = new SqliteConnection(new SqliteConnectionStringBuilder
|
||||
{
|
||||
DataSource = databasePath,
|
||||
Mode = SqliteOpenMode.ReadWrite, // never Create: a missing ledger is "off", not a new file
|
||||
Pooling = false,
|
||||
DefaultTimeout = 2,
|
||||
}.ToString());
|
||||
connection.Open();
|
||||
using (SqliteCommand readOnly = connection.CreateCommand())
|
||||
{
|
||||
readOnly.CommandText = "PRAGMA query_only = 1";
|
||||
readOnly.ExecuteNonQuery();
|
||||
}
|
||||
|
||||
using SqliteCommand command = connection.CreateCommand();
|
||||
command.CommandText = "SELECT value FROM settings WHERE key = $key";
|
||||
command.Parameters.AddWithValue("$key", Key);
|
||||
return command.ExecuteScalar() is string value && string.Equals(value, "1", StringComparison.Ordinal);
|
||||
}
|
||||
catch (SqliteException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
catch (InvalidOperationException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
using System.ComponentModel;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Principal;
|
||||
using FrameLedger.Infrastructure.Ipc;
|
||||
using Windows.Win32;
|
||||
using Windows.Win32.Foundation;
|
||||
using Windows.Win32.Security;
|
||||
using Windows.Win32.System.Threading;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// A named mutex whose security descriptor is stated rather than defaulted (beta.10, the Agent's admin mode, D34): owned by
|
||||
/// this process's user, full access to the user, Administrators and SYSTEM, nothing to anyone else.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Why not <see cref="Mutex"/>.</b> A mutex takes the creating token's default DACL, and an elevated token's grants
|
||||
/// Administrators and SYSTEM and not the user — the trap <see cref="PipeAccessControl"/> and the tolerance channel already
|
||||
/// state. The ledger's migration lock is taken by every process that opens the ledger: an elevated Agent that created it
|
||||
/// while migrating would have refused the same user's unelevated App with an access-denied at the one moment both open the
|
||||
/// ledger — at logon, after an update.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Held, then released.</b> Unlike the Agent's instance lock (created, never waited on), this one is waited on: two
|
||||
/// processes serialise on it. An abandoned wait — the holder died mid-migration — is the lock taken, and says so.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class SharedMutex : IDisposable
|
||||
{
|
||||
private HANDLE _handle;
|
||||
|
||||
private SharedMutex(HANDLE handle) => _handle = handle;
|
||||
|
||||
/// <summary><c>O:<user>D:P(A;;GA;;;<user>)(A;;GA;;;BA)(A;;GA;;;SY)</c>: the user's, whoever created it.</summary>
|
||||
public static string Sddl(SecurityIdentifier user)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(user);
|
||||
return $"O:{user.Value}D:P(A;;GA;;;{user.Value})(A;;GA;;;BA)(A;;GA;;;SY)";
|
||||
}
|
||||
|
||||
/// <summary>Creates <paramref name="name"/>, or opens it when another process of this user created it first.</summary>
|
||||
/// <exception cref="Win32Exception">It could be neither created nor opened.</exception>
|
||||
public static unsafe SharedMutex CreateOrOpen(string name)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(name);
|
||||
byte[] descriptor = PipeAccessControl.DescriptorBytes(Sddl(PipeAccessControl.CurrentUser()));
|
||||
fixed (char* n = name)
|
||||
fixed (byte* sd = descriptor)
|
||||
{
|
||||
var attributes = new SECURITY_ATTRIBUTES
|
||||
{
|
||||
nLength = (uint)sizeof(SECURITY_ATTRIBUTES),
|
||||
lpSecurityDescriptor = sd,
|
||||
bInheritHandle = false,
|
||||
};
|
||||
HANDLE handle = PInvoke.CreateMutex(&attributes, false, new PCWSTR(n));
|
||||
// Read at once: the generated declaration may not set the last P/Invoke error (PipeServer records the same).
|
||||
int error = Marshal.GetLastSystemError();
|
||||
if (handle.IsNull)
|
||||
{
|
||||
throw new Win32Exception(error, $"CreateMutex({name}): {Marshal.GetPInvokeErrorMessage(error)} (error {error})");
|
||||
}
|
||||
|
||||
return new SharedMutex(handle);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Waits up to <paramref name="timeout"/>; true when the lock is this process's (an abandoned one included).</summary>
|
||||
public bool Wait(TimeSpan timeout, out bool abandoned)
|
||||
{
|
||||
ObjectDisposedException.ThrowIf(_handle.IsNull, this);
|
||||
uint ms = (uint)Math.Clamp(timeout.TotalMilliseconds, 0, uint.MaxValue - 1);
|
||||
WAIT_EVENT result = PInvoke.WaitForSingleObject(_handle, ms);
|
||||
abandoned = result == WAIT_EVENT.WAIT_ABANDONED;
|
||||
return result is WAIT_EVENT.WAIT_OBJECT_0 or WAIT_EVENT.WAIT_ABANDONED;
|
||||
}
|
||||
|
||||
/// <summary>Releases a lock this thread holds.</summary>
|
||||
public void Release()
|
||||
{
|
||||
ObjectDisposedException.ThrowIf(_handle.IsNull, this);
|
||||
_ = PInvoke.ReleaseMutex(_handle);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (!_handle.IsNull)
|
||||
{
|
||||
_ = PInvoke.CloseHandle(_handle);
|
||||
_handle = default;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
using Windows.Win32;
|
||||
using Windows.Win32.Foundation;
|
||||
using Windows.Win32.Security;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// The privileges this process's token has ENABLED, by name — read, never changed (beta.10, the Agent's admin mode, D34).
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// An elevated token HOLDS powerful privileges (debug, load-driver) disabled; enabling one takes an explicit
|
||||
/// <c>AdjustTokenPrivileges</c>, which nothing in <c>src/</c> may call (<c>tools/chokepoint-check.ps1</c>). This is the
|
||||
/// other half: the Agent logs what is enabled when it starts elevated, and a test on an elevated runner asserts that
|
||||
/// opening a target and the CPU sensors enabled nothing — third-party code included.
|
||||
/// </remarks>
|
||||
public static class TokenPrivileges
|
||||
{
|
||||
/// <summary>The enabled privileges' names (<c>SeChangeNotifyPrivilege</c>, …), or empty when the token could not be read.</summary>
|
||||
public static unsafe IReadOnlyList<string> Enabled()
|
||||
{
|
||||
HANDLE token;
|
||||
if (!PInvoke.OpenProcessToken(PInvoke.GetCurrentProcess(), TOKEN_ACCESS_MASK.TOKEN_QUERY, &token))
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
// Written through a pointer the analyzers cannot follow (CA1508 would call the size check dead).
|
||||
uint* length = stackalloc uint[1];
|
||||
_ = PInvoke.GetTokenInformation(token, TOKEN_INFORMATION_CLASS.TokenPrivileges, null, 0, length);
|
||||
if (*length == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
byte[] buffer = new byte[*length];
|
||||
fixed (byte* p = buffer)
|
||||
{
|
||||
if (!PInvoke.GetTokenInformation(token, TOKEN_INFORMATION_CLASS.TokenPrivileges, p, (uint)buffer.Length, length))
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
var privileges = (TOKEN_PRIVILEGES*)p;
|
||||
LUID_AND_ATTRIBUTES* each = (LUID_AND_ATTRIBUTES*)&privileges->Privileges;
|
||||
var names = new List<string>((int)privileges->PrivilegeCount);
|
||||
for (uint i = 0; i < privileges->PrivilegeCount; i++)
|
||||
{
|
||||
if (each[i].Attributes.HasFlag(TOKEN_PRIVILEGES_ATTRIBUTES.SE_PRIVILEGE_ENABLED) && NameOf(each[i].Luid) is { } name)
|
||||
{
|
||||
names.Add(name);
|
||||
}
|
||||
}
|
||||
|
||||
return names;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
_ = PInvoke.CloseHandle(token);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether process <paramref name="pid"/> runs elevated (<c>TokenElevation</c>), or null when its token cannot be read —
|
||||
/// how the Agent says in its log that a game it started runs with a standard user's rights, and how a test checks it.
|
||||
/// </summary>
|
||||
public static unsafe bool? IsElevated(int pid)
|
||||
{
|
||||
HANDLE process = PInvoke.OpenProcess(Windows.Win32.System.Threading.PROCESS_ACCESS_RIGHTS.PROCESS_QUERY_LIMITED_INFORMATION, false, (uint)pid);
|
||||
if (process.IsNull)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
HANDLE token = default;
|
||||
try
|
||||
{
|
||||
if (!PInvoke.OpenProcessToken(process, TOKEN_ACCESS_MASK.TOKEN_QUERY, &token))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
TOKEN_ELEVATION elevation;
|
||||
uint* length = stackalloc uint[1];
|
||||
return PInvoke.GetTokenInformation(token, TOKEN_INFORMATION_CLASS.TokenElevation, &elevation, (uint)sizeof(TOKEN_ELEVATION), length)
|
||||
? elevation.TokenIsElevated != 0
|
||||
: null;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (!token.IsNull)
|
||||
{
|
||||
_ = PInvoke.CloseHandle(token);
|
||||
}
|
||||
|
||||
_ = PInvoke.CloseHandle(process);
|
||||
}
|
||||
}
|
||||
|
||||
private static unsafe string? NameOf(LUID luid)
|
||||
{
|
||||
char* name = stackalloc char[64];
|
||||
uint length = 64;
|
||||
return PInvoke.LookupPrivilegeName(default, &luid, new PWSTR(name), &length) ? new string(name, 0, (int)length) : null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
using System.Collections;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using Windows.Win32;
|
||||
using Windows.Win32.Foundation;
|
||||
using Windows.Win32.Security;
|
||||
using Windows.Win32.System.Threading;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// Starts a program with the token the desktop shell runs with (beta.10, the Agent's admin mode, owner decision D34): what a
|
||||
/// game started by an ELEVATED Agent gets — the same token it would get from a double-click — never the Agent's own.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Why it matters.</b> <c>LaunchGame</c> reaches the Agent over the pipe, which any process of the same user may open, and
|
||||
/// a game row is a file path any such process could write into the ledger. An elevated Agent that started games with its own
|
||||
/// token would be an elevation for everything running under the account, with no prompt. So an elevated Agent starts games
|
||||
/// through this, and refuses to start one when it cannot (no shell to take the token from) rather than start it elevated.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>How.</b> The shell window's process (<c>GetShellWindow</c>), its token duplicated as a primary token, and
|
||||
/// <c>CreateProcessWithTokenW</c> — documented, and it needs only <c>SeImpersonatePrivilege</c>, which an elevated
|
||||
/// administrator's token holds enabled; nothing here enables a privilege. The explicit environment block is this process's
|
||||
/// with the caller's variables on top, which is what <see cref="System.Diagnostics.ProcessStartInfo"/> would pass.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class UnelevatedProcess
|
||||
{
|
||||
/// <summary><c>ERROR_INVALID_WINDOW_HANDLE</c>: there is no desktop shell window to take a standard user's token from.</summary>
|
||||
public const int ErrorNoShell = 1400;
|
||||
|
||||
/// <summary>The desktop shell's process id (<c>GetShellWindow</c>'s owner), or null when there is no shell.</summary>
|
||||
public static unsafe int? ShellProcessId()
|
||||
{
|
||||
HWND shell = PInvoke.GetShellWindow();
|
||||
uint* pid = stackalloc uint[1];
|
||||
return shell.IsNull || PInvoke.GetWindowThreadProcessId(shell, pid) == 0 || *pid == 0 ? null : (int)*pid;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Starts <paramref name="exePath"/>; the process and its id, or null with the Win32 error in <paramref name="error"/>. The
|
||||
/// returned handle keeps the id from being reused until the caller has pinned the process its own way and disposed it.
|
||||
/// </summary>
|
||||
public static unsafe (int Pid, IDisposable Process)? Start(string exePath, string arguments, string workingDirectory,
|
||||
IReadOnlyDictionary<string, string> environment, out int error)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
|
||||
ArgumentNullException.ThrowIfNull(environment);
|
||||
error = 0;
|
||||
|
||||
if (ShellProcessId() is not { } shellPid)
|
||||
{
|
||||
error = ErrorNoShell;
|
||||
return null;
|
||||
}
|
||||
|
||||
HANDLE shellProcess = PInvoke.OpenProcess(PROCESS_ACCESS_RIGHTS.PROCESS_QUERY_LIMITED_INFORMATION, false, (uint)shellPid);
|
||||
if (shellProcess.IsNull)
|
||||
{
|
||||
error = Marshal.GetLastSystemError();
|
||||
return null;
|
||||
}
|
||||
|
||||
HANDLE shellToken = default;
|
||||
HANDLE primary = default;
|
||||
try
|
||||
{
|
||||
if (!PInvoke.OpenProcessToken(shellProcess, TOKEN_ACCESS_MASK.TOKEN_DUPLICATE, &shellToken))
|
||||
{
|
||||
error = Marshal.GetLastSystemError();
|
||||
return null;
|
||||
}
|
||||
|
||||
const TOKEN_ACCESS_MASK access = TOKEN_ACCESS_MASK.TOKEN_QUERY | TOKEN_ACCESS_MASK.TOKEN_DUPLICATE | TOKEN_ACCESS_MASK.TOKEN_ASSIGN_PRIMARY
|
||||
| TOKEN_ACCESS_MASK.TOKEN_ADJUST_DEFAULT | TOKEN_ACCESS_MASK.TOKEN_ADJUST_SESSIONID;
|
||||
if (!PInvoke.DuplicateTokenEx(shellToken, access, null, SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation, TOKEN_TYPE.TokenPrimary, &primary))
|
||||
{
|
||||
error = Marshal.GetLastSystemError();
|
||||
return null;
|
||||
}
|
||||
|
||||
return Create(primary, exePath, arguments, workingDirectory, environment, out error);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (!primary.IsNull)
|
||||
{
|
||||
_ = PInvoke.CloseHandle(primary);
|
||||
}
|
||||
|
||||
if (!shellToken.IsNull)
|
||||
{
|
||||
_ = PInvoke.CloseHandle(shellToken);
|
||||
}
|
||||
|
||||
_ = PInvoke.CloseHandle(shellProcess);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The block <c>CreateProcessWithTokenW</c> takes: <c>name=value\0</c> per variable, sorted, then <c>\0</c>.</summary>
|
||||
public static string EnvironmentBlock(IReadOnlyDictionary<string, string> overrides)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(overrides);
|
||||
var merged = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||||
foreach (DictionaryEntry entry in Environment.GetEnvironmentVariables())
|
||||
{
|
||||
if (entry.Key is string name && name.Length > 0 && entry.Value is string value)
|
||||
{
|
||||
merged[name] = value;
|
||||
}
|
||||
}
|
||||
|
||||
foreach ((string name, string value) in overrides)
|
||||
{
|
||||
merged[name] = value;
|
||||
}
|
||||
|
||||
var block = new StringBuilder();
|
||||
foreach ((string name, string value) in merged)
|
||||
{
|
||||
block.Append(name).Append('=').Append(value).Append('\0');
|
||||
}
|
||||
|
||||
return block.Append('\0').ToString();
|
||||
}
|
||||
|
||||
private static unsafe (int Pid, IDisposable Process)? Create(HANDLE token, string exePath, string arguments, string workingDirectory,
|
||||
IReadOnlyDictionary<string, string> environment, out int error)
|
||||
{
|
||||
error = 0;
|
||||
// The command line is written to by the call, so it is a buffer of its own; the program is named in quotes, as
|
||||
// Process.Start would name it.
|
||||
char[] commandLine = ("\"" + exePath + "\"" + (string.IsNullOrEmpty(arguments) ? string.Empty : " " + arguments) + "\0").ToCharArray();
|
||||
string block = EnvironmentBlock(environment);
|
||||
var startup = new STARTUPINFOW { cb = (uint)sizeof(STARTUPINFOW) };
|
||||
PROCESS_INFORMATION started;
|
||||
fixed (char* application = exePath)
|
||||
fixed (char* line = commandLine)
|
||||
fixed (char* env = block)
|
||||
fixed (char* directory = workingDirectory)
|
||||
{
|
||||
if (!PInvoke.CreateProcessWithToken(token, default, new PCWSTR(application), new PWSTR(line),
|
||||
PROCESS_CREATION_FLAGS.CREATE_UNICODE_ENVIRONMENT, env, string.IsNullOrEmpty(workingDirectory) ? default : new PCWSTR(directory),
|
||||
&startup, &started))
|
||||
{
|
||||
error = Marshal.GetLastSystemError();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
_ = PInvoke.CloseHandle(started.hThread);
|
||||
return ((int)started.dwProcessId, new ProcessHandle(started.hProcess));
|
||||
}
|
||||
|
||||
private sealed class ProcessHandle(HANDLE handle) : IDisposable
|
||||
{
|
||||
private HANDLE _handle = handle;
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (!_handle.IsNull)
|
||||
{
|
||||
_ = PInvoke.CloseHandle(_handle);
|
||||
_handle = default;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -121,6 +121,8 @@ public sealed record HelloRequest(string AppVersion, int Protocol);
|
||||
/// <c>DisclosureVersion</c> (P3 PR-4, D14) is the FR-2.1 text this Agent stamps against; the App refuses to open
|
||||
/// the consent dialog when it differs from its own <c>SafetyDisclosure.Version</c>. <c>ExceptionDisclosureVersion</c>
|
||||
/// (D33) is the same rule for the user-mode exception's disclosure (<c>AntiCheatExceptionDisclosure.Version</c>).
|
||||
/// <c>ElevationOutcome</c> (beta.10, D34) is the admin mode's answer at this Agent's start — <c>granted</c>, <c>declined</c>,
|
||||
/// <c>other-account</c>, <c>failed</c> — or null when nobody asked; an older Agent sends none, which reads as not asked.
|
||||
/// </summary>
|
||||
public sealed record HelloAck(
|
||||
string AgentVersion,
|
||||
@@ -132,7 +134,8 @@ public sealed record HelloAck(
|
||||
string? TelemetrySource,
|
||||
bool CpuTempAvailable,
|
||||
string? DisclosureVersion = null,
|
||||
string? ExceptionDisclosureVersion = null);
|
||||
string? ExceptionDisclosureVersion = null,
|
||||
string? ElevationOutcome = null);
|
||||
|
||||
/// <summary><c>GetStatus</c>: no payload.</summary>
|
||||
public sealed record GetStatusRequest;
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
namespace FrameLedger.Shared.Safety;
|
||||
|
||||
/// <summary>
|
||||
/// The version of the admin mode's disclosure this build carries (beta.10, owner decision D34) — the
|
||||
/// <c>Safety_AdminMode_*</c> strings in <c>Strings.resx</c> beside this file, shown before <c>capture.run_elevated</c> is
|
||||
/// turned on. The same discipline as <see cref="SafetyDisclosure"/>: bump it whenever a <c>Safety_AdminMode_*</c> string
|
||||
/// changes MEANING in any language.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Nothing records an acceptance of it: the option being on is the acceptance, turning it on always shows the text, and
|
||||
/// Windows asks again at every start of the Agent — which is the consent that matters, and it is Windows' own.
|
||||
/// </remarks>
|
||||
public static class AgentAdminDisclosure
|
||||
{
|
||||
public const string Version = "agent-admin-dialog/1";
|
||||
}
|
||||
+27
@@ -26,6 +26,15 @@ public static class Strings
|
||||
/// <summary>Every key, for an audit that walks them.</summary>
|
||||
public static IReadOnlyList<string> Keys { get; } =
|
||||
[
|
||||
nameof(Safety_AdminMode_Accept),
|
||||
nameof(Safety_AdminMode_Adds),
|
||||
nameof(Safety_AdminMode_Cancel),
|
||||
nameof(Safety_AdminMode_Intro),
|
||||
nameof(Safety_AdminMode_Prompt),
|
||||
nameof(Safety_AdminMode_Risk),
|
||||
nameof(Safety_AdminMode_Title),
|
||||
nameof(Safety_AdminMode_TurnOn),
|
||||
nameof(Safety_AdminMode_Unchanged),
|
||||
nameof(Safety_AutoDisabled_Format),
|
||||
nameof(Safety_Blocked_Toggle_Format),
|
||||
nameof(Safety_Consent_AgentUnavailable),
|
||||
@@ -63,6 +72,24 @@ public static class Strings
|
||||
nameof(Safety_Unhooked_Format),
|
||||
];
|
||||
|
||||
public static string Safety_AdminMode_Accept => ResourceManager.GetString(nameof(Safety_AdminMode_Accept), Culture) ?? nameof(Safety_AdminMode_Accept);
|
||||
|
||||
public static string Safety_AdminMode_Adds => ResourceManager.GetString(nameof(Safety_AdminMode_Adds), Culture) ?? nameof(Safety_AdminMode_Adds);
|
||||
|
||||
public static string Safety_AdminMode_Cancel => ResourceManager.GetString(nameof(Safety_AdminMode_Cancel), Culture) ?? nameof(Safety_AdminMode_Cancel);
|
||||
|
||||
public static string Safety_AdminMode_Intro => ResourceManager.GetString(nameof(Safety_AdminMode_Intro), Culture) ?? nameof(Safety_AdminMode_Intro);
|
||||
|
||||
public static string Safety_AdminMode_Prompt => ResourceManager.GetString(nameof(Safety_AdminMode_Prompt), Culture) ?? nameof(Safety_AdminMode_Prompt);
|
||||
|
||||
public static string Safety_AdminMode_Risk => ResourceManager.GetString(nameof(Safety_AdminMode_Risk), Culture) ?? nameof(Safety_AdminMode_Risk);
|
||||
|
||||
public static string Safety_AdminMode_Title => ResourceManager.GetString(nameof(Safety_AdminMode_Title), Culture) ?? nameof(Safety_AdminMode_Title);
|
||||
|
||||
public static string Safety_AdminMode_TurnOn => ResourceManager.GetString(nameof(Safety_AdminMode_TurnOn), Culture) ?? nameof(Safety_AdminMode_TurnOn);
|
||||
|
||||
public static string Safety_AdminMode_Unchanged => ResourceManager.GetString(nameof(Safety_AdminMode_Unchanged), Culture) ?? nameof(Safety_AdminMode_Unchanged);
|
||||
|
||||
public static string Safety_AutoDisabled_Format => ResourceManager.GetString(nameof(Safety_AutoDisabled_Format), Culture) ?? nameof(Safety_AutoDisabled_Format);
|
||||
|
||||
public static string Safety_Blocked_Toggle_Format => ResourceManager.GetString(nameof(Safety_Blocked_Toggle_Format), Culture) ?? nameof(Safety_Blocked_Toggle_Format);
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
<data name="Safety_Refused_Unnamed" xml:space="preserve"><value>An anti-cheat or anti-tamper module was detected in this game. FrameLedger will not inject into it, and nothing overrides that.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_HookingTurnedOff" xml:space="preserve"><value>Hooking has been turned off for this game; its page says what was found.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Unhooked_Format" xml:space="preserve"><value>Capture stopped: {0} was detected while the game was running. FrameLedger unhooked and will not inject into this game again until you enable it again.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>The game is running, but Windows would not let FrameLedger open its process: it is protected by an anti-cheat driver, or it runs as administrator while FrameLedger does not. Nothing was injected and this run was not measured. FrameLedger will not work around another product's protection.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>The game is running, but Windows would not let FrameLedger open its process: it is protected by an anti-cheat driver, or it runs as administrator while FrameLedger does not. Nothing was injected and this run was not measured. FrameLedger will not work around another product's protection. If the game itself runs as administrator, the agent's admin mode in Settings lets FrameLedger open it; a protected process stays closed.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_Title_Format" xml:space="preserve"><value>Make a user-mode exception for {0}?</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_Intro_Format" xml:space="preserve"><value>FrameLedger found {0} in this game ({1}) and turned its hooking off. This dialog asks whether to make an exception for this game only. It recommends neither choice.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_Why_Format" xml:space="preserve"><value>The exception is offered because {0} runs entirely in user mode — no kernel driver, no service and no driver file in the game's folder — and FrameLedger has already measured this game hooked, successfully, {1} times.</value><comment>safety: human review required</comment></data>
|
||||
@@ -43,6 +43,42 @@
|
||||
<data name="Safety_Exception_Accept" xml:space="preserve"><value>I accept the risk of a ban for this game</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_Grant" xml:space="preserve"><value>Make the exception</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_Cancel" xml:space="preserve"><value>Keep it blocked</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_AdminMode_Title" xml:space="preserve">
|
||||
<value>Run the capture agent as administrator?</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Intro" xml:space="preserve">
|
||||
<value>The capture agent normally runs with your standard rights, and every capture tier works that way. This option asks Windows to start it as administrator instead.</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Adds" xml:space="preserve">
|
||||
<value>What it adds: FrameLedger can open and measure a game that itself runs as administrator, and it can read the CPU temperature where PawnIO is installed.</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Unchanged" xml:space="preserve">
|
||||
<value>What it does not change: a game with anti-cheat is still refused, and a process Windows protects stays unreadable. A Vulkan game that runs as administrator is still not measured, because Windows does not load FrameLedger's Vulkan layer into it. Games you start from FrameLedger still run with your standard rights.</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Prompt" xml:space="preserve">
|
||||
<value>Windows asks you every time the agent starts — at logon too, when its prompt may wait on the taskbar — and it names an unknown publisher, because FrameLedger is not signed. If you answer No, the agent runs with your standard rights and says so. If another administrator account answers, that agent refuses to run, because its data would not be yours.</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Risk" xml:space="preserve">
|
||||
<value>The risk is yours: FrameLedger is installed in your user folder, which any program running under your account can change. A program that replaced FrameLedger's files would run as administrator the next time you accept this prompt. Turn this on only if you trust everything that runs under your account.</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Accept" xml:space="preserve">
|
||||
<value>I understand, and I want Windows to ask each time the agent starts</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_TurnOn" xml:space="preserve">
|
||||
<value>Turn on</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Cancel" xml:space="preserve">
|
||||
<value>Keep standard rights</value>
|
||||
<comment>safety: human review required</comment>
|
||||
</data>
|
||||
<data name="Safety_Exception_VersionMismatch" xml:space="preserve"><value>This app and the capture agent carry different versions of this text. Nothing was granted. Restart both, then try again.</value><comment>safety: human review required</comment></data>
|
||||
<data name="Safety_Exception_OptionOff" xml:space="preserve"><value>The user-mode exception option is off in Settings, so nothing was granted.</value><comment>safety: human review required</comment></data>
|
||||
</root>
|
||||
@@ -36,7 +36,7 @@
|
||||
<data name="Safety_Refused_Unnamed" xml:space="preserve"><value>An anti-cheat or anti-tamper module was detected in this game. FrameLedger will not inject into it, and nothing overrides that.</value></data>
|
||||
<data name="Safety_HookingTurnedOff" xml:space="preserve"><value>Hooking has been turned off for this game; its page says what was found.</value></data>
|
||||
<data name="Safety_Unhooked_Format" xml:space="preserve"><value>Capture stopped: {0} was detected while the game was running. FrameLedger unhooked and will not inject into this game again until you enable it again.</value></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>The game is running, but Windows would not let FrameLedger open its process: it is protected by an anti-cheat driver, or it runs as administrator while FrameLedger does not. Nothing was injected and this run was not measured. FrameLedger will not work around another product's protection.</value></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>The game is running, but Windows would not let FrameLedger open its process: it is protected by an anti-cheat driver, or it runs as administrator while FrameLedger does not. Nothing was injected and this run was not measured. FrameLedger will not work around another product's protection. If the game itself runs as administrator, the agent's admin mode in Settings lets FrameLedger open it; a protected process stays closed.</value></data>
|
||||
<data name="Safety_Exception_Title_Format" xml:space="preserve"><value>Make a user-mode exception for {0}?</value></data>
|
||||
<data name="Safety_Exception_Intro_Format" xml:space="preserve"><value>FrameLedger found {0} in this game ({1}) and turned its hooking off. This dialog asks whether to make an exception for this game only. It recommends neither choice.</value></data>
|
||||
<data name="Safety_Exception_Why_Format" xml:space="preserve"><value>The exception is offered because {0} runs entirely in user mode — no kernel driver, no service and no driver file in the game's folder — and FrameLedger has already measured this game hooked, successfully, {1} times.</value></data>
|
||||
@@ -48,6 +48,33 @@
|
||||
<data name="Safety_Exception_Accept" xml:space="preserve"><value>I accept the risk of a ban for this game</value></data>
|
||||
<data name="Safety_Exception_Grant" xml:space="preserve"><value>Make the exception</value></data>
|
||||
<data name="Safety_Exception_Cancel" xml:space="preserve"><value>Keep it blocked</value></data>
|
||||
<data name="Safety_AdminMode_Title" xml:space="preserve">
|
||||
<value>Run the capture agent as administrator?</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Intro" xml:space="preserve">
|
||||
<value>The capture agent normally runs with your standard rights, and every capture tier works that way. This option asks Windows to start it as administrator instead.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Adds" xml:space="preserve">
|
||||
<value>What it adds: FrameLedger can open and measure a game that itself runs as administrator, and it can read the CPU temperature where PawnIO is installed.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Unchanged" xml:space="preserve">
|
||||
<value>What it does not change: a game with anti-cheat is still refused, and a process Windows protects stays unreadable. A Vulkan game that runs as administrator is still not measured, because Windows does not load FrameLedger's Vulkan layer into it. Games you start from FrameLedger still run with your standard rights.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Prompt" xml:space="preserve">
|
||||
<value>Windows asks you every time the agent starts — at logon too, when its prompt may wait on the taskbar — and it names an unknown publisher, because FrameLedger is not signed. If you answer No, the agent runs with your standard rights and says so. If another administrator account answers, that agent refuses to run, because its data would not be yours.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Risk" xml:space="preserve">
|
||||
<value>The risk is yours: FrameLedger is installed in your user folder, which any program running under your account can change. A program that replaced FrameLedger's files would run as administrator the next time you accept this prompt. Turn this on only if you trust everything that runs under your account.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Accept" xml:space="preserve">
|
||||
<value>I understand, and I want Windows to ask each time the agent starts</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_TurnOn" xml:space="preserve">
|
||||
<value>Turn on</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Cancel" xml:space="preserve">
|
||||
<value>Keep standard rights</value>
|
||||
</data>
|
||||
<data name="Safety_Exception_VersionMismatch" xml:space="preserve"><value>This app and the capture agent carry different versions of this text. Nothing was granted. Restart both, then try again.</value></data>
|
||||
<data name="Safety_Exception_OptionOff" xml:space="preserve"><value>The user-mode exception option is off in Settings, so nothing was granted.</value></data>
|
||||
</root>
|
||||
@@ -30,7 +30,7 @@
|
||||
<data name="Safety_Refused_Unnamed" xml:space="preserve"><value>Đã phát hiện một mô-đun anti-cheat hoặc anti-tamper trong game này. FrameLedger sẽ không inject vào game này, và không có cách nào vượt qua điều đó.</value></data>
|
||||
<data name="Safety_HookingTurnedOff" xml:space="preserve"><value>Hooking đã được tắt cho game này; trang của game ghi rõ đã phát hiện gì.</value></data>
|
||||
<data name="Safety_Unhooked_Format" xml:space="preserve"><value>Đã dừng thu thập: phát hiện {0} khi game đang chạy. FrameLedger đã gỡ hook và sẽ không inject vào game này nữa cho đến khi bạn bật lại.</value></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>Game đang chạy, nhưng Windows không cho FrameLedger mở tiến trình của nó: tiến trình được driver anti-cheat bảo vệ, hoặc game chạy với quyền quản trị còn FrameLedger thì không. Không có gì được inject và lần chạy này không được đo. FrameLedger sẽ không tìm cách vượt qua cơ chế bảo vệ của sản phẩm khác.</value></data>
|
||||
<data name="Safety_Refused_TargetUnreadable" xml:space="preserve"><value>Game đang chạy, nhưng Windows không cho FrameLedger mở tiến trình của nó: tiến trình được driver anti-cheat bảo vệ, hoặc game chạy với quyền quản trị còn FrameLedger thì không. Không có gì được inject và lần chạy này không được đo. FrameLedger sẽ không tìm cách vượt qua cơ chế bảo vệ của sản phẩm khác. Nếu chính game chạy với quyền quản trị, chế độ quản trị của agent trong Cài đặt cho phép FrameLedger mở nó; tiến trình được bảo vệ vẫn đóng.</value></data>
|
||||
<data name="Safety_Exception_Title_Format" xml:space="preserve"><value>Tạo ngoại lệ user-mode cho {0}?</value></data>
|
||||
<data name="Safety_Exception_Intro_Format" xml:space="preserve"><value>FrameLedger đã phát hiện {0} trong game này ({1}) và đã tắt hooking cho nó. Hộp thoại này hỏi bạn có muốn tạo ngoại lệ cho riêng game này không. Nó không khuyến nghị lựa chọn nào.</value></data>
|
||||
<data name="Safety_Exception_Why_Format" xml:space="preserve"><value>Ngoại lệ được đề xuất vì {0} chạy hoàn toàn ở user mode — không có kernel driver, không có service và không có tệp driver nào trong thư mục game — và FrameLedger đã đo game này ở chế độ hook thành công {1} lần.</value></data>
|
||||
@@ -42,6 +42,33 @@
|
||||
<data name="Safety_Exception_Accept" xml:space="preserve"><value>Tôi chấp nhận rủi ro bị khoá tài khoản cho game này</value></data>
|
||||
<data name="Safety_Exception_Grant" xml:space="preserve"><value>Tạo ngoại lệ</value></data>
|
||||
<data name="Safety_Exception_Cancel" xml:space="preserve"><value>Giữ chặn</value></data>
|
||||
<data name="Safety_AdminMode_Title" xml:space="preserve">
|
||||
<value>Chạy capture agent với quyền quản trị?</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Intro" xml:space="preserve">
|
||||
<value>Capture agent bình thường chạy với quyền người dùng thường của bạn, và mọi tier ghi nhận đều hoạt động như vậy. Tuỳ chọn này yêu cầu Windows khởi động nó với quyền quản trị thay vào đó.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Adds" xml:space="preserve">
|
||||
<value>Điều nó thêm vào: FrameLedger có thể mở và đo một game tự chạy với quyền quản trị, và có thể đọc nhiệt độ CPU ở máy đã cài PawnIO.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Unchanged" xml:space="preserve">
|
||||
<value>Điều nó không thay đổi: game có anti-cheat vẫn bị từ chối, và tiến trình được Windows bảo vệ vẫn không đọc được. Game Vulkan chạy với quyền quản trị vẫn không được đo, vì Windows không nạp Vulkan layer của FrameLedger vào nó. Game bạn khởi động từ FrameLedger vẫn chạy với quyền người dùng thường.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Prompt" xml:space="preserve">
|
||||
<value>Windows sẽ hỏi bạn mỗi lần agent khởi động — cả lúc đăng nhập, khi hộp thoại có thể nằm chờ trên thanh tác vụ — và ghi nhà phát hành là không xác định, vì FrameLedger không được ký số. Nếu bạn chọn Không, agent chạy với quyền người dùng thường và nói rõ điều đó. Nếu một tài khoản quản trị khác trả lời, agent đó sẽ không chạy, vì dữ liệu của nó không phải của bạn.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Risk" xml:space="preserve">
|
||||
<value>Rủi ro là của bạn: FrameLedger được cài trong thư mục người dùng của bạn, nơi mọi chương trình chạy dưới tài khoản của bạn đều có thể sửa đổi. Một chương trình đã thay thế các file của FrameLedger sẽ chạy với quyền quản trị vào lần tiếp theo bạn chấp nhận hộp thoại này. Chỉ bật khi bạn tin tưởng mọi thứ chạy dưới tài khoản của mình.</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Accept" xml:space="preserve">
|
||||
<value>Tôi đã hiểu, và muốn Windows hỏi mỗi lần agent khởi động</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_TurnOn" xml:space="preserve">
|
||||
<value>Bật</value>
|
||||
</data>
|
||||
<data name="Safety_AdminMode_Cancel" xml:space="preserve">
|
||||
<value>Giữ quyền người dùng thường</value>
|
||||
</data>
|
||||
<data name="Safety_Exception_VersionMismatch" xml:space="preserve"><value>Ứng dụng và capture agent đang mang hai phiên bản khác nhau của văn bản này. Không có gì được cấp. Hãy khởi động lại cả hai rồi thử lại.</value></data>
|
||||
<data name="Safety_Exception_OptionOff" xml:space="preserve"><value>Tuỳ chọn ngoại lệ user-mode đang tắt trong Cài đặt, nên không có gì được cấp.</value></data>
|
||||
</root>
|
||||
@@ -137,4 +137,32 @@ public sealed class AgentCommandLineSurfaceTests
|
||||
AgentCommandLine.Parse(["--console", "capture", "--exe", "g.exe"]).PartialFlushSeconds.Should().Be(0, "absent is the product's interval");
|
||||
AgentCommandLine.Parse(["--console", "capture", "--exe", "g.exe", "--partial-flush-seconds", "2"]).PartialFlushSeconds.Should().Be(2);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.10 (the admin mode, owner decision D34): <c>--serve</c> takes exactly one of two options, each about the Agent's
|
||||
/// own rights and neither about a directory, a target or a check — the account an elevated Agent must be, or the answer
|
||||
/// its starter already got.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ServeTakesOnlyTheAdminModesTwoOptions()
|
||||
{
|
||||
string sid = FrameLedger.Infrastructure.Startup.AgentElevation.CurrentUserSid();
|
||||
AgentCommandLine forUser = AgentCommandLine.Parse(["--serve", "--for-user", sid]);
|
||||
forUser.Error.Should().BeNull();
|
||||
forUser.Verb.Should().Be(AgentVerb.Serve);
|
||||
forUser.ForUser.Should().Be(sid);
|
||||
forUser.DataDirectory.Should().BeNull("the profile's folder, and nothing else");
|
||||
|
||||
AgentCommandLine declined = AgentCommandLine.Parse(["--serve", "--elevation", "declined"]);
|
||||
declined.Error.Should().BeNull();
|
||||
declined.ElevationRefusal.Should().Be("declined");
|
||||
AgentCommandLine.Parse(["--serve", "--elevation", "other-account"]).ElevationRefusal.Should().Be("other-account");
|
||||
AgentCommandLine.Parse(["--serve", "--elevation", "failed"]).ElevationRefusal.Should().Be("failed");
|
||||
|
||||
AgentCommandLine.Parse(["--serve", "--for-user", "not-a-sid"]).Error.Should().Contain("needs a SID");
|
||||
AgentCommandLine.Parse(["--serve", "--elevation", "granted"]).Error.Should().NotBeNull("an elevated Agent is started with --for-user, never told it was granted");
|
||||
AgentCommandLine.Parse(["--serve", "--for-user", sid, "--elevation", "declined"]).Error.Should().NotBeNull("one or the other");
|
||||
AgentCommandLine.Parse(["--serve", "--for-user"]).Error.Should().NotBeNull();
|
||||
AgentCommandLine.Parse(["--serve", "--exe", "g.exe"]).Error.Should().Contain("only under --console");
|
||||
}
|
||||
}
|
||||
@@ -50,6 +50,11 @@ public sealed class AgentConnectionTests : IAsyncDisposable
|
||||
|
||||
public int Starts { get; private set; }
|
||||
|
||||
/// <summary>beta.10: whether the start would show Windows' administrator prompt.</summary>
|
||||
public bool Asks { get; set; }
|
||||
|
||||
public bool WillAskForElevation => Asks;
|
||||
|
||||
public bool TryStart()
|
||||
{
|
||||
Starts++;
|
||||
@@ -269,6 +274,27 @@ public sealed class AgentConnectionTests : IAsyncDisposable
|
||||
launcher.RunningAgent.Should().BeNull("the claim went with its handle");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.10 (the admin mode): a start that is waiting for Windows' administrator prompt counts as an Agent on its way, so
|
||||
/// the App never shows a second prompt beside the logon task's; and the launcher asks only when the option is on and this
|
||||
/// App is a standard user's.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void TheLauncherSeesAPendingElevationAndAsksOnlyWhenTheOptionIsOn()
|
||||
{
|
||||
string folder = Path.Combine(Path.GetTempPath(), "fl-launcher-" + Guid.NewGuid().ToString("N"));
|
||||
var launcher = new AgentLauncher(folder, runElevated: static () => true);
|
||||
using (ElevationMarker? pending = ElevationMarker.TryAcquire(folder))
|
||||
{
|
||||
pending.Should().NotBeNull();
|
||||
launcher.RunningAgent.Should().Contain("administrator");
|
||||
}
|
||||
|
||||
launcher.RunningAgent.Should().BeNull();
|
||||
launcher.WillAskForElevation.Should().Be(!Environment.IsPrivilegedProcess, "an elevated App's Agent inherits its rights, and is never prompted for");
|
||||
new AgentLauncher(folder).WillAskForElevation.Should().BeFalse("no ledger in the folder: the option reads off");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ALostAgentIsOfflineAndAReturningOneIsConnectedAgain()
|
||||
{
|
||||
@@ -285,4 +311,24 @@ public sealed class AgentConnectionTests : IAsyncDisposable
|
||||
c.RetryNow();
|
||||
await WaitForAsync(() => c.State == AgentConnectionState.Connected && c.Hello is not null, "back").ConfigureAwait(true);
|
||||
}
|
||||
|
||||
/// <summary>beta.10 (the admin mode): a start that asks Windows for administrator rights says so on the pill while it waits.</summary>
|
||||
[Fact]
|
||||
public async Task AStartThatAsksForAdministratorRightsSaysSoOnThePill()
|
||||
{
|
||||
FakeLauncher? launcher = null;
|
||||
launcher = new FakeLauncher(() =>
|
||||
{
|
||||
StartServer();
|
||||
return true;
|
||||
})
|
||||
{ CanLaunch = true, Asks = true };
|
||||
AgentConnection c = Start(launcher);
|
||||
|
||||
await WaitForAsync(() => c.State == AgentConnectionState.Connected, "started, then connected").ConfigureAwait(true);
|
||||
lock (_seen)
|
||||
{
|
||||
_seen.Should().Contain(AgentConnectionState.Elevating).And.NotContain(AgentConnectionState.Starting);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,11 @@ internal sealed class FakeAgentLink : IAgentLink
|
||||
|
||||
public void SetLaunchHold(bool hold) => Holds.Add(hold);
|
||||
|
||||
/// <summary>How many times a round was asked to run now (beta.10: the admin mode's restart).</summary>
|
||||
public int Retries { get; private set; }
|
||||
|
||||
public void RetryNow() => Retries++;
|
||||
|
||||
public Func<string, object, IpcEnvelope> Answer { get; set; } = static (_, _) => throw new InvalidOperationException("no answer scripted");
|
||||
|
||||
public event EventHandler? Changed;
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
using System.Globalization;
|
||||
using System.Windows;
|
||||
using FluentAssertions;
|
||||
using FrameLedger.App.Services;
|
||||
@@ -114,7 +115,20 @@ public sealed class SettingsViewModelTests
|
||||
public required FakeFirstRun FirstRun { get; init; }
|
||||
}
|
||||
|
||||
private static async Task<Harness> OpenAsync(ScratchLedger s, FakeAgentLink? agent = null, FakeRun? run = null, FakeMaintenance? maintenance = null, FakeTool? tool = null)
|
||||
/// <summary>The admin mode's disclosure, answering as told and counting how often it was shown.</summary>
|
||||
private sealed class ScriptedAdminPrompt(bool answer) : IAgentAdminPrompt
|
||||
{
|
||||
public int Shown { get; private set; }
|
||||
|
||||
public Task<bool> ShowAsync(CancellationToken ct = default)
|
||||
{
|
||||
Shown++;
|
||||
return Task.FromResult(answer);
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task<Harness> OpenAsync(ScratchLedger s, FakeAgentLink? agent = null, FakeRun? run = null, FakeMaintenance? maintenance = null, FakeTool? tool = null,
|
||||
IAgentAdminPrompt? adminPrompt = null)
|
||||
{
|
||||
maintenance ??= new FakeMaintenance();
|
||||
tool ??= new FakeTool();
|
||||
@@ -128,7 +142,9 @@ public sealed class SettingsViewModelTests
|
||||
run ??= new FakeRun();
|
||||
var strip = new RecordingStrip();
|
||||
var shell = new ShellHost(new ServiceCollection().BuildServiceProvider(), null!, null!, closePolicy);
|
||||
var vm = new SettingsViewModel(appearance, new NoTheme(), shell, settings, s.Library, new HookingConsent(agent, new NoPrompt()), agent, run, strip, maintenance, tool, closePolicy, firstRun);
|
||||
// The instance-lock probe is the test's (never the real folder's): no Agent holds it, so a restart never waits.
|
||||
var vm = new SettingsViewModel(appearance, new NoTheme(), shell, settings, s.Library, new HookingConsent(agent, new NoPrompt()), agent, run, strip, maintenance, tool, closePolicy, firstRun,
|
||||
adminPrompt: adminPrompt, agentHeld: static () => false);
|
||||
Task pending = vm.Pending;
|
||||
await pending.ConfigureAwait(false);
|
||||
return new Harness { Ledger = s, Settings = settings, Agent = agent, Run = run, Strip = strip, Vm = vm, Maintenance = maintenance, Tool = tool, ClosePolicy = closePolicy, FirstRun = firstRun };
|
||||
@@ -497,4 +513,89 @@ public sealed class SettingsViewModelTests
|
||||
LoggingLevel.SetDebug(false);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.10 (the admin mode, owner decision D34): off by default; turning it on shows the disclosure first and writes
|
||||
/// nothing when it is not accepted; accepted, the row is written and the Agent is asked to stop, then started the new way.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task TheAdminModeAsksFirstAndRestartsTheAgent()
|
||||
{
|
||||
await using ScratchLedger s = await ScratchLedger.OpenAsync();
|
||||
var declined = new ScriptedAdminPrompt(answer: false);
|
||||
Harness h = await OpenAsync(s, adminPrompt: declined);
|
||||
h.Vm.RunElevated.Should().BeFalse("off by default");
|
||||
|
||||
h.Vm.RunElevated = true;
|
||||
Task pending101 = h.Vm.Pending;
|
||||
await pending101.ConfigureAwait(true);
|
||||
|
||||
declined.Shown.Should().Be(1);
|
||||
h.Vm.RunElevated.Should().BeFalse("not accepted, so it stays off");
|
||||
(await new SqliteSettingsStore(s.Db).GetAsync(SettingsRegistry.CaptureRunElevated.Key, Ct).ConfigureAwait(true)).Should().BeNull("nothing was written");
|
||||
h.Agent.Sent.Should().BeEmpty();
|
||||
|
||||
var accepted = new ScriptedAdminPrompt(answer: true);
|
||||
Harness on = await OpenAsync(s, adminPrompt: accepted).ConfigureAwait(true);
|
||||
on.Agent.Answer = static (_, _) => FakeAgentLink.Envelope(IpcMessageType.ShutdownAck, new ShutdownAck());
|
||||
on.Vm.RunElevated = true;
|
||||
Task pending103 = on.Vm.Pending;
|
||||
await pending103.ConfigureAwait(true);
|
||||
|
||||
(await on.Settings.GetBooleanAsync(SettingsRegistry.CaptureRunElevated, Ct).ConfigureAwait(true)).Should().BeTrue();
|
||||
on.Agent.Sent.Select(static m => m.Type).Should().Equal(IpcMessageType.Shutdown);
|
||||
on.Agent.Retries.Should().Be(1, "the next round starts the Agent, asking Windows");
|
||||
on.Strip.Shown.Should().Contain(static m => m.Body == Strings.Settings_Agent_RunElevated_Restarting);
|
||||
|
||||
on.Vm.RunElevated = false;
|
||||
Task pending104 = on.Vm.Pending;
|
||||
await pending104.ConfigureAwait(true);
|
||||
accepted.Shown.Should().Be(1, "turning it off asks nothing");
|
||||
(await on.Settings.GetBooleanAsync(SettingsRegistry.CaptureRunElevated, Ct).ConfigureAwait(true)).Should().BeFalse();
|
||||
on.Agent.Retries.Should().Be(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task TheAdminModeNeverRestartsTheAgentUnderARunningSession()
|
||||
{
|
||||
await using ScratchLedger s = await ScratchLedger.OpenAsync();
|
||||
var agent = new FakeAgentLink
|
||||
{
|
||||
Status = new StatusAck("recording", null, 2, [new ActiveSession(Guid.NewGuid(), 1, "Title", 100, 2, DateTimeOffset.UtcNow)]),
|
||||
};
|
||||
Harness h = await OpenAsync(s, agent, adminPrompt: new ScriptedAdminPrompt(answer: true));
|
||||
|
||||
h.Vm.RunElevated = true;
|
||||
Task pending102 = h.Vm.Pending;
|
||||
await pending102.ConfigureAwait(true);
|
||||
|
||||
(await h.Settings.GetBooleanAsync(SettingsRegistry.CaptureRunElevated, Ct).ConfigureAwait(true)).Should().BeTrue("saved; it applies at the next start");
|
||||
h.Agent.Sent.Should().BeEmpty("a Shutdown would end the session");
|
||||
h.Agent.Retries.Should().Be(0);
|
||||
h.Strip.Shown.Should().Contain(static m => m.Body == Strings.Settings_Agent_RunElevated_AfterSession);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheAgentsRightsAreSaidWithWhyAStandardUsersAgentIsOne()
|
||||
{
|
||||
CultureInfo? previous = Strings.Culture;
|
||||
Strings.Culture = CultureInfo.GetCultureInfo("en");
|
||||
try
|
||||
{
|
||||
static HelloAck Hello(bool elevated, string? outcome) => new("a", IpcProtocol.Version, 1, elevated, null, false, null, false, ElevationOutcome: outcome);
|
||||
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Elevating, null).Should().Be(Strings.Agent_State_Elevating);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Offline, null).Should().Be(Strings.Settings_VkLayer_Unknown);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(true, "granted")).Should().Be(Strings.Settings_Agent_Elevated);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(true, null)).Should().Be(Strings.Settings_Agent_Elevated, "inherited is elevated too");
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(false, "declined")).Should().Be(Strings.Settings_Agent_ElevationDeclined);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(false, "other-account")).Should().Be(Strings.Settings_Agent_ElevationOtherAccount);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(false, "failed")).Should().Be(Strings.Settings_Agent_ElevationFailed);
|
||||
SettingsViewModel.ElevationTextOf(AgentConnectionState.Connected, Hello(false, null)).Should().Be(Strings.Settings_Agent_NotElevated);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Strings.Culture = previous;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -47,9 +47,12 @@ public sealed class UpdateServiceTests
|
||||
|
||||
public UpdateService Service { get; }
|
||||
|
||||
/// <summary>Whether an Agent process still holds the data folder (beta.10) — this test's, never the real folder's lock.</summary>
|
||||
public bool AgentHeld { get; set; }
|
||||
|
||||
public Harness(TimeSpan? agentStop = null)
|
||||
{
|
||||
Service = new UpdateService(Client, Agent, new RegisteredSettings(Store), Prompts, Shell, Strip, agentStop);
|
||||
Service = new UpdateService(Client, Agent, new RegisteredSettings(Store), Prompts, Shell, Strip, agentStop, () => AgentHeld);
|
||||
Service.Available += (_, e) => Available.Add(e.Version);
|
||||
}
|
||||
}
|
||||
@@ -295,7 +298,7 @@ public sealed class UpdateServiceTests
|
||||
{
|
||||
var h = new Harness();
|
||||
h.Store.Rows[SettingsRegistry.UpdateChannel.Key] = "stable";
|
||||
using var faulting = new UpdateService(new ThrowingClient(), h.Agent, new RegisteredSettings(h.Store), h.Prompts, h.Shell, h.Strip);
|
||||
using var faulting = new UpdateService(new ThrowingClient(), h.Agent, new RegisteredSettings(h.Store), h.Prompts, h.Shell, h.Strip, agentHeld: static () => false);
|
||||
|
||||
await faulting.CheckInteractivelyAsync(Ct);
|
||||
|
||||
@@ -404,4 +407,43 @@ public sealed class UpdateServiceTests
|
||||
h.Shell.Quits.Should().Be(0);
|
||||
h.Agent.Holds.Should().BeEmpty();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.10 (the admin mode): an Agent can hold the data folder — and the install directory's files — without answering
|
||||
/// this App (an elevated one still starting, one of another version). Nothing is applied under it.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task AnAgentThatHoldsTheFolderWithoutAnsweringIsNeverUpdatedUnder()
|
||||
{
|
||||
var h = new Harness(TimeSpan.FromMilliseconds(300)) { AgentHeld = true };
|
||||
h.Agent.IsConnected = false;
|
||||
h.Client.Next = Candidate();
|
||||
await h.Service.CheckSilentlyAsync(Ct);
|
||||
|
||||
await h.Service.RestartToUpdateAsync(Ct);
|
||||
|
||||
h.Client.Applied.Should().BeEmpty("the files are still in use by an Agent process");
|
||||
h.Shell.Quits.Should().Be(0);
|
||||
h.Strip.Shown.Should().ContainSingle().Which.Body.Should().Be(Strings.Update_AgentStillRunning);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task TheApplyWaitsUntilTheStoppedAgentsProcessHasLetGo()
|
||||
{
|
||||
var h = new Harness(TimeSpan.FromSeconds(5)) { AgentHeld = true };
|
||||
h.Client.Next = Candidate();
|
||||
await h.Service.CheckSilentlyAsync(Ct);
|
||||
h.Agent.Answer = (_, _) =>
|
||||
{
|
||||
// The pipe drops at once; the process lets go of the folder a little later, as an exiting Agent does.
|
||||
h.Agent.IsConnected = false;
|
||||
_ = Task.Delay(300, Ct).ContinueWith(_ => h.AgentHeld = false, Ct, TaskContinuationOptions.None, TaskScheduler.Default);
|
||||
return FakeAgentLink.Envelope(IpcMessageType.ShutdownAck, new ShutdownAck());
|
||||
};
|
||||
|
||||
await h.Service.RestartToUpdateAsync(Ct);
|
||||
|
||||
h.Client.Applied.Should().Equal("0.2.0");
|
||||
h.AgentHeld.Should().BeFalse("the apply ran only after the folder was let go");
|
||||
}
|
||||
}
|
||||
@@ -31,13 +31,28 @@ public sealed class SettingsRegistryTests
|
||||
d.AgentReads.Should().BeTrue("the Agent reads it at every session start and command");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// D34: the admin mode is off unless the user turns it on — and the reader that runs before the Agent exists
|
||||
/// (<c>Infrastructure.Startup.RunElevatedSetting</c>, which cannot reference this project's registry) names the same key.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void TheAdminModeIsOffByDefaultAndItsEarlyReaderNamesTheSameKey()
|
||||
{
|
||||
SettingDefinition d = SettingsRegistry.CaptureRunElevated;
|
||||
d.Key.Should().Be("capture.run_elevated");
|
||||
d.Default.Should().Be("0");
|
||||
d.Kind.Should().Be(SettingKind.Boolean);
|
||||
FrameLedger.Infrastructure.Startup.RunElevatedSetting.Key.Should().Be(d.Key);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheAgentReadsExactlyTheFourPrefixesD16Names()
|
||||
{
|
||||
string[] agent = [.. SettingsRegistry.All.Where(static d => d.AgentReads).Select(static d => d.Key)];
|
||||
// hooking.usermode_ac_exceptions joined on 2026-09-26 (D33): the user-mode exception's option, off by default.
|
||||
agent.Should().BeEquivalentTo(["capture.background", "hooking.kill_switch", "hooking.usermode_ac_exceptions", "capture.min_session_s",
|
||||
"telemetry.interval_ms", "retention.raw_sessions_per_game"]);
|
||||
// capture.run_elevated joined on 2026-09-27 (D34): the admin mode, read before the Agent exists.
|
||||
agent.Should().BeEquivalentTo(["capture.background", "hooking.kill_switch", "hooking.usermode_ac_exceptions", "capture.run_elevated",
|
||||
"capture.min_session_s", "telemetry.interval_ms", "retention.raw_sessions_per_game"]);
|
||||
agent.Should().OnlyContain(static k => k.StartsWith("hooking.", StringComparison.Ordinal) || k.StartsWith("capture.", StringComparison.Ordinal)
|
||||
|| k.StartsWith("telemetry.", StringComparison.Ordinal) || k.StartsWith("retention.", StringComparison.Ordinal));
|
||||
}
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
using System.Diagnostics;
|
||||
using System.Security.AccessControl;
|
||||
using System.Security.Principal;
|
||||
using FluentAssertions;
|
||||
using FrameLedger.Infrastructure.Ipc;
|
||||
using FrameLedger.Infrastructure.Persistence;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using Microsoft.Data.Sqlite;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Tests.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// The Agent's admin mode (beta.10, owner decision D34), below the prompt: the setting read before the Agent exists, the
|
||||
/// marker that keeps two prompts from racing, the account check, the lock whose DACL survives an elevated creator, and the
|
||||
/// start that gives a game the shell's token. The UAC prompt itself is the owner's to check on real hardware (HANDOFF).
|
||||
/// </summary>
|
||||
public sealed class AgentElevationTests : IDisposable
|
||||
{
|
||||
private readonly string _dir = Path.Combine(Path.GetTempPath(), "fl-elev-" + Guid.NewGuid().ToString("N"));
|
||||
|
||||
public AgentElevationTests() => Directory.CreateDirectory(_dir);
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
SqliteConnection.ClearAllPools();
|
||||
try
|
||||
{
|
||||
Directory.Delete(_dir, recursive: true);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
// A pooled handle can outlive the test; a scratch folder left under %TEMP% is not worth a red build.
|
||||
}
|
||||
}
|
||||
|
||||
private string Ledger => Path.Combine(_dir, LedgerPaths.DatabaseFileName);
|
||||
|
||||
[Fact]
|
||||
public async Task TheSettingIsOnOnlyWhenTheLedgerSaysExactlyOne()
|
||||
{
|
||||
RunElevatedSetting.Read(Ledger).Should().BeFalse("no ledger yet is off — and nothing is created");
|
||||
File.Exists(Ledger).Should().BeFalse();
|
||||
|
||||
await using (LedgerDatabase db = await LedgerDatabase.OpenAsync(Ledger, ct: TestContext.Current.CancellationToken))
|
||||
{
|
||||
RunElevatedSetting.Read(Ledger).Should().BeFalse("a ledger without the row is off (the registry's default)");
|
||||
await new SqliteSettingsStore(db).SetAsync(RunElevatedSetting.Key, "1", TestContext.Current.CancellationToken);
|
||||
RunElevatedSetting.Read(Ledger).Should().BeTrue("read while the writer's connection is open, as the App reads it beside the Agent");
|
||||
await new SqliteSettingsStore(db).SetAsync(RunElevatedSetting.Key, "0", TestContext.Current.CancellationToken);
|
||||
RunElevatedSetting.Read(Ledger).Should().BeFalse();
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ALedgerWithoutASettingsTableIsOffAndIsNotMigrated()
|
||||
{
|
||||
// The first start after an update meets a ledger at an older schema; this read must neither fail nor migrate it.
|
||||
using (var connection = new SqliteConnection(new SqliteConnectionStringBuilder { DataSource = Ledger, Pooling = false }.ToString()))
|
||||
{
|
||||
connection.Open();
|
||||
using SqliteCommand create = connection.CreateCommand();
|
||||
create.CommandText = "CREATE TABLE unrelated (x INTEGER)";
|
||||
create.ExecuteNonQuery();
|
||||
}
|
||||
|
||||
RunElevatedSetting.Read(Ledger).Should().BeFalse();
|
||||
using (var check = new SqliteConnection(new SqliteConnectionStringBuilder { DataSource = Ledger, Pooling = false }.ToString()))
|
||||
{
|
||||
check.Open();
|
||||
using SqliteCommand tables = check.CreateCommand();
|
||||
tables.CommandText = "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table'";
|
||||
tables.ExecuteScalar().Should().Be(1L, "nothing was written to the file");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void OneStartAtATimeMayAskForElevation()
|
||||
{
|
||||
ElevationMarker.IsHeld(_dir).Should().BeFalse();
|
||||
using (ElevationMarker? first = ElevationMarker.TryAcquire(_dir))
|
||||
{
|
||||
first.Should().NotBeNull();
|
||||
ElevationMarker.IsHeld(_dir).Should().BeTrue();
|
||||
ElevationMarker.TryAcquire(_dir).Should().BeNull("a second prompt beside the first");
|
||||
AgentInstanceLock.IsHeld(_dir).Should().BeFalse("the marker is its own object, not the Agent's claim");
|
||||
}
|
||||
|
||||
ElevationMarker.IsHeld(_dir).Should().BeFalse("the marker goes with its handle");
|
||||
ElevationMarker.NameFor(_dir).Should().StartWith(@"Local\FrameLedger.Agent.Elevating.")
|
||||
.And.EndWith(AgentInstanceLock.NameFor(_dir)[@"Local\FrameLedger.Agent.".Length..], "the folder's key, its own name");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheElevatedAgentKnowsWhetherItIsTheUserWhoAsked()
|
||||
{
|
||||
string me = AgentElevation.CurrentUserSid();
|
||||
AgentElevation.IsCurrentUser(me).Should().BeTrue();
|
||||
AgentElevation.IsCurrentUser("s" + me[1..]).Should().BeTrue("a SID's letter compares without case");
|
||||
AgentElevation.IsCurrentUser("S-1-5-18").Should().BeFalse("LocalSystem is another account");
|
||||
AgentElevation.Refusals.Should().Equal(AgentElevation.Declined, AgentElevation.OtherAccount, AgentElevation.Failed);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheMigrationLockIsTheUsersWhoeverCreatedIt()
|
||||
{
|
||||
SecurityIdentifier user = PipeAccessControl.CurrentUser();
|
||||
var descriptor = new RawSecurityDescriptor(SharedMutex.Sddl(user));
|
||||
descriptor.Owner.Should().Be(user, "an elevated creator's default owner would be Administrators");
|
||||
descriptor.DiscretionaryAcl!.Cast<CommonAce>().Select(static a => a.SecurityIdentifier)
|
||||
.Should().Contain(user, "the same user's unelevated process opens it — an elevated default DACL does not list the user");
|
||||
|
||||
string name = @"Local\FrameLedger.Test.Mutex." + Guid.NewGuid().ToString("N");
|
||||
using SharedMutex first = SharedMutex.CreateOrOpen(name);
|
||||
using SharedMutex second = SharedMutex.CreateOrOpen(name);
|
||||
first.Wait(TimeSpan.FromSeconds(1), out bool abandoned).Should().BeTrue();
|
||||
abandoned.Should().BeFalse();
|
||||
first.Release();
|
||||
second.Wait(TimeSpan.FromSeconds(1), out _).Should().BeTrue("released, the other handle takes it");
|
||||
second.Release();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheEnvironmentBlockIsThisProcessesWithTheCallersOnTopSortedAndDoublyTerminated()
|
||||
{
|
||||
string block = UnelevatedProcess.EnvironmentBlock(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
["FL_TEST_VARIABLE"] = "yes",
|
||||
["PATH"] = "C:\\only",
|
||||
});
|
||||
|
||||
block.Should().EndWith("\0\0");
|
||||
string[] entries = block.TrimEnd('\0').Split('\0');
|
||||
entries.Should().Contain("FL_TEST_VARIABLE=yes");
|
||||
// A variable the process already has keeps ITS name's casing ("Path" on the hosted runner, measured 2026-09-27):
|
||||
// Windows compares names without case, so the caller's value replaces it rather than standing beside it.
|
||||
entries.Where(static e => e.StartsWith("PATH=", StringComparison.OrdinalIgnoreCase)).Should()
|
||||
.ContainSingle().Which.Should().EndWith("=C:\\only");
|
||||
entries.Select(static e => e[..e.IndexOf('=', StringComparison.Ordinal)]).Should().BeInAscendingOrder(StringComparer.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// What an elevated Agent gives a game (D34): the shell's token. On an unelevated run there is nothing to test — the call
|
||||
/// needs the impersonation privilege an elevated token holds — and a machine without a shell has no token to give; both
|
||||
/// skip. Where it runs, the child's elevation is the SHELL's: a runner with UAC off has an elevated shell, and a game
|
||||
/// started from it would be elevated by a double-click too.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void AGameStartedByAnElevatedAgentGetsTheShellsElevation()
|
||||
{
|
||||
Assert.SkipUnless(Environment.IsPrivilegedProcess, "CreateProcessWithTokenW needs SeImpersonatePrivilege, which only an elevated token holds");
|
||||
int? shell = UnelevatedProcess.ShellProcessId();
|
||||
Assert.SkipWhen(shell is null, "no desktop shell in this session");
|
||||
string cmd = Path.Combine(Environment.SystemDirectory, "cmd.exe");
|
||||
|
||||
(int Pid, IDisposable Process)? started = UnelevatedProcess.Start(cmd, "/c ping -n 3 127.0.0.1 >nul", _dir,
|
||||
new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), out int error);
|
||||
|
||||
started.Should().NotBeNull($"the start failed with Win32 error {error}");
|
||||
using (started!.Value.Process)
|
||||
{
|
||||
TokenPrivileges.IsElevated(started.Value.Pid).Should().Be(TokenPrivileges.IsElevated(shell!.Value),
|
||||
"the game runs as a double-click would run it, never with the Agent's token");
|
||||
using Process child = Process.GetProcessById(started.Value.Pid);
|
||||
child.WaitForExit(10_000).Should().BeTrue();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
using FluentAssertions;
|
||||
using FrameLedger.Infrastructure.Capture;
|
||||
using FrameLedger.Infrastructure.Io;
|
||||
using FrameLedger.Infrastructure.Startup;
|
||||
using FrameLedger.Infrastructure.Telemetry;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Tests.Startup;
|
||||
|
||||
/// <summary>
|
||||
/// Nothing the Agent does ENABLES a privilege (beta.10, the admin mode, D34). An elevated token holds the debug and
|
||||
/// load-driver privileges disabled; <c>src/</c> may not enable one (<c>tools/chokepoint-check.ps1</c>), and this checks what
|
||||
/// the code actually does, third-party code included — the resolver opening processes, LibreHardwareMonitor opening the CPU
|
||||
/// group as the elevated Agent's CPU temperature does.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Meaningful on an elevated run, which CI is: an unelevated token does not hold these privileges at all, so there the
|
||||
/// assertions pass by construction. <b>Relative, not absolute:</b> the hosted runner's token ARRIVES with
|
||||
/// <c>SeDebugPrivilege</c> enabled (measured 2026-09-27 — the runner is an administrator's service), so what is asserted
|
||||
/// is that nothing here enables a powerful privilege that was not already on. If a library ever enables one, this goes
|
||||
/// red on CI — and that is a question for the owner, not a line to relax.
|
||||
/// </remarks>
|
||||
public sealed class PrivilegeFootprintTests
|
||||
{
|
||||
private static readonly string[] _powerful =
|
||||
["SeDebugPrivilege", "SeLoadDriverPrivilege", "SeTcbPrivilege", "SeTakeOwnershipPrivilege", "SeBackupPrivilege", "SeRestorePrivilege"];
|
||||
|
||||
[Fact]
|
||||
public void OpeningTargetsAndTheCpuSensorsEnablesNoPowerfulPrivilege()
|
||||
{
|
||||
IReadOnlyList<string> before = TokenPrivileges.Enabled();
|
||||
before.Should().Contain("SeChangeNotifyPrivilege", "every token has it enabled; an empty answer would be a reader that read nothing");
|
||||
|
||||
_ = new TargetResolver().Resolve(ExecutableIdentity.Normalise(Environment.ProcessPath!), out _);
|
||||
using (var cpu = new LhmCpuTemperatureReader(new LhmComputerAdapter(enableCpuAndMemory: true, enableGpu: false)))
|
||||
{
|
||||
_ = cpu.Read();
|
||||
}
|
||||
|
||||
string[] newlyEnabled = [.. TokenPrivileges.Enabled().Except(before, StringComparer.Ordinal)];
|
||||
newlyEnabled.Should().NotContain(_powerful,
|
||||
$"opening a target and the CPU sensors enabled a privilege (elevated run: {Environment.IsPrivilegedProcess}; enabled before: {string.Join(", ", before)})");
|
||||
}
|
||||
}
|
||||
@@ -96,13 +96,25 @@ $forbiddenEverywhere = @(
|
||||
@{ Pattern = 'ZwSetInformationThread'; Why = 'thread hiding — evasion, permanently out of scope' }
|
||||
)
|
||||
|
||||
# Enabling a privilege is not this project's either (beta.10, the Agent's admin mode, owner decision D34). An elevated
|
||||
# Agent's token HOLDS the debug and load-driver privileges disabled, and nothing FrameLedger does needs one enabled: the
|
||||
# guard's driver scan asks NtQuerySystemInformation, a target is opened with ordinary rights. A privilege enabled "for a
|
||||
# moment" is how an elevated tool becomes a way to read any process on the machine. src/ only: a test may NAME a privilege
|
||||
# to assert that it stays disabled (tests/FrameLedger.Infrastructure.Tests/Startup/PrivilegeFootprintTests.cs).
|
||||
$forbiddenInSrc = @(
|
||||
@{ Pattern = 'AdjustTokenPrivileges'; Why = 'enabling a token privilege — the admin mode enables none' },
|
||||
@{ Pattern = 'RtlAdjustPrivilege'; Why = 'enabling a token privilege (undocumented) — the admin mode enables none' },
|
||||
@{ Pattern = 'EnterDebugMode'; Why = 'Process.EnterDebugMode enables SeDebugPrivilege' },
|
||||
@{ Pattern = 'SeDebugPrivilege'; Why = 'the debug privilege — reading any process; nothing under src/ may name it' }
|
||||
)
|
||||
|
||||
$checkedFile = $false
|
||||
foreach ($src in $sources) {
|
||||
$rel = [IO.Path]::GetRelativePath($nativeRoot, $src.FullName) -replace '\\', '/'
|
||||
$isChokepoint = $rel -eq $chokepoint
|
||||
if ($isChokepoint) { $checkedFile = $true }
|
||||
|
||||
foreach ($rule in ($chokepointOnly + $forbiddenEverywhere)) {
|
||||
foreach ($rule in ($chokepointOnly + $forbiddenEverywhere + $forbiddenInSrc)) {
|
||||
# Skip comments: this file, and the guard, describe these APIs at length
|
||||
# on purpose. A rule that fired on prose would be turned off within a week.
|
||||
$hits = @(Select-String -Path $src.FullName -Pattern $rule.Pattern -SimpleMatch |
|
||||
@@ -142,7 +154,8 @@ if ($managedSources.Count -eq 0) {
|
||||
|
||||
foreach ($src in $managedSources) {
|
||||
$rel = [IO.Path]::GetRelativePath($Root, $src.FullName) -replace '\\', '/'
|
||||
foreach ($rule in ($chokepointOnly + $forbiddenEverywhere)) {
|
||||
$rules = if ($rel.StartsWith('src/', [StringComparison]::Ordinal)) { $chokepointOnly + $forbiddenEverywhere + $forbiddenInSrc } else { $chokepointOnly + $forbiddenEverywhere }
|
||||
foreach ($rule in $rules) {
|
||||
$hits = @(Select-String -Path $src.FullName -Pattern $rule.Pattern -SimpleMatch |
|
||||
Where-Object { $_.Line.TrimStart() -notmatch '^(//|///|\*|/\*)' })
|
||||
foreach ($h in $hits) {
|
||||
|
||||
Reference in new issue
Block a user