Skip to content

Commit ae57979

Browse files
araza008jamieknvidiadrew
authored
feat(mxc): add Windows ETW-to-OCSF audit trail (NVIDIA#3015)
* feat(mxc): ETW->OCSF audit consumer + Windows OCSF JSONL parity (cp6 P1) Add a Windows MXC ETW->OCSF audit trail in openshell-driver-mxc: a real-time Sandboxing-provider ETW consumer that decodes events (TDH), attributes each to an OpenShell sandbox_id, and maps them to OCSF (lifecycle 6002, config 5019, process 1007, finding 2004). cp6 Phase 1 - durable OCSF JSONL audit-file parity with Linux: - openshell-ocsf: add emit_ocsf_event_routed (populates the event-bridge thread-local AND stamps sandbox_id+message in one dispatch) plus public set/clear_current_event; OS-aware device (Device::windows/for_current_os) so device.os.name reflects the host instead of a hardcoded Linux stub. - etw_consumer: emit via the routed emit (previously fired a bare info! that never populated the bridge, so the structured event was dropped). - openshell-server: install OcsfJsonlLayer over a synchronous daily-rotated appender (durable under force-kill), gated by OPENSHELL_OCSF_JSON, path via %PROGRAMDATA%\OpenShell\logs (override OPENSHELL_OCSF_LOG_DIR). - device.hostname now resolves to the real gateway machine name. Box-proven on 7F203-MXC-001: JSONL lines == shorthand OCSF rows, all valid OCSF JSON, per-sandbox attribution intact, disabled state writes nothing. Signed-off-by: Akber Raza <[email protected]> * feat(mxc): map remaining Sandboxing ETW events to OCSF Close the last three ETW->OCSF gaps so the audit trail covers the full set of events the Sandboxing provider emits (12/12): - ProcessLaunched -> Process Activity [1007] "Launch" (confirmed start; carries the real processId/threadId, the twin of CreateProcessInSandbox which only has the request + command line). - SandboxProxyConfigured -> Device Config State Change [5019] (the one network-plane setup event; surfaces proxyPort, "no proxy" when 0). - SandboxConsoleReferencePlumbed -> Device Config State Change [5019] (console-handle plumbing). map_config_state now handles the full config/hardening/setup family and carries proxyPort/hasConsoleReference/creationFlags as unmapped fields. Verified on 7F203-MXC-001: 11/12 event types emit OCSF without a proxy (SandboxProxyConfigured requires proxy config to fire). Signed-off-by: Akber Raza <[email protected]> * fix(mxc): seed ETW attribution under registry lock + Device tests Address CodeRabbit review on !31: - Prevent stale ETW attribution on a delete/launch race: register the wxc-exec pid while holding the registry lock, and bail if the sandbox entry is already gone. Previously the attribution key could be seeded after `delete` had removed the sandbox, leaving a stale key that could misroute later Sandboxing ETW events to a dead sandbox_id. Lock order (registry -> attribution) matches the delete path, so no deadlock. - Add unit tests for the new Device::windows and Device::for_current_os constructors to harden Windows/Linux OCSF device parity. Signed-off-by: Akber Raza <[email protected]> * fix(mxc-etw): buffer+replay racing events and harden attribution keys Addresses two ETW->OCSF attribution review items (Shailendra #1, #2). #2 early-event loss: ETW delivers the sandbox create/config burst the instant wxc-exec starts, which can beat the driver's register_launch (now under the registry lock post-Ready). process_event previously dropped anything unresolved, losing the racing burst. Add a bounded, time-bounded pending buffer (PENDING_MAX=4096, PENDING_TTL=5s): unresolved events are held and replayed once attribution lands, aged-out ones dropped. Consumer switched to a timed recv_timeout(200ms) so the buffer is re-driven after each event and on a tick. Emit path factored into shared emit_resolved(). #1 attribution collisions: a Windows PID is recycled after exit and a command line is commonly identical across sandboxes. register_launch now rebinds by_pid on reuse and clears the stale last_pid_sid hint (warns if the PID still pointed at a different, leaked sandbox); command line is held in by_cmd only while unique and demoted to a new ambiguous_cmds set on a second owner, so a duplicate command refuses to resolve rather than misroute. Unit tests: buffer replay (direct + cross-link), buffer bound, PID-reuse rebind, duplicate-cmd non-resolution. Box-verified on 7F203-MXC-001 (5 sandboxes, identical cmd -> 5 isolated sandbox_ids, 50/50 OCSF/JSONL, BuffersLost=0). Signed-off-by: Akber Raza <[email protected]> * docs(mxc-etw): note cmd_line is captured raw with no privacy filtering Review item NVIDIA#3 (Shailendra): add a PRIVACY NOTE on map_process_launch stating cmd_line is copied verbatim into OCSF process.cmd_line with no redaction, so secrets/PII on a command line land unredacted in the durable audit trail (deliberate audit-fidelity trade-off; treat the log as sensitive). Redaction is owned by an upstream privacy layer, not this path; no general audit-output PII scrubber exists today (openshell_core::secrets [CREDENTIAL] redaction is scoped to the proxy HTTP-target logging, a separate egress path). Signed-off-by: Akber Raza <[email protected]> * fix(mxc-etw): open ETW trace on caller thread so start_session reports real status Review item NVIDIA#4 (Shailendra): start_session previously returned Ok(EtwSession) as soon as the pump thread was spawned, but OpenTraceW ran later inside that thread; if it failed we still handed back a live-looking session and logged 'consumer started' (silent failure = false audit coverage). Split the two Win32 calls instead of adding a channel handshake (avoids any lost-wakeup/hang risk): the quick, synchronous OpenTraceW now runs on the caller thread (open_trace), and only the blocking ProcessTrace runs on the pump thread (run_trace). start_session returns Err if OpenTraceW fails (reclaiming the boxed Sender so the consumer disconnects, stopping the session, joining the consumer) and returns Ok/logs 'started' only once capture is genuinely open. Opened handle + LoggerName buffer + boxed Sender are carried to the pump via a Send OpenedTrace so they outlive ProcessTrace. Box-verified on 7F203-MXC-001: consumer started=True, failed-to-start=False, 50 OCSF rows / 50 JSONL, BuffersLost=0 (no regression to capture/emit). Signed-off-by: Akber Raza <[email protected]> * fix(mxc-etw): guard pending-event replay against PID recycling CodeRabbit flagged that drain_resolved() re-resolved buffered events against the live by_pid map, so if Windows recycled a wxc-exec PID within PENDING_TTL a stale event from the dead sandbox could be emitted under the new owner. Stamp each by_pid registration with its Instant and add resolve_replay(), used only on the buffered/replay path. It (a) never falls back to the recycle-/ambiguity-prone by_cmd or last_pid_sid keys, and (b) trusts a PID match only when the registration is not newer than the buffered event by more than REPLAY_PID_GRACE (2s) - a recycled PID's registration lands well outside that window, so the stale event ages out instead of misattributing. The legitimate #2 seed race (registration lands ~immediately) still replays. Adds unit tests for the recycle-refusal, in-grace acceptance, and weak-fallback exclusion. Signed-off-by: Akber Raza <[email protected]> * fix(mxc-etw): surface unexpected ProcessTrace termination (review NVIDIA#4) start_session already returns Err on OpenTraceW failure (runs on the caller thread since e41a770), closing the first half of Shailendra's NVIDIA#4. This closes the second half: ProcessTrace's result was discarded, so if capture died mid-run the backend had no way to know. Add a shared CaptureHealth (stopped/stopping/exit_code) between the pump thread and EtwSession. run_trace now records ProcessTrace's WIN32_ERROR and, when the pump returns without a deliberate stop, logs at ERROR that MXC OCSF capture is no longer running. EtwSession::stop() sets `stopping` before teardown so a normal shutdown isn't misreported, and EtwSession::is_capture_alive() exposes the state for status/diagnostics. Box-verified on 7F203-MXC-001: 5 sandboxes, 50 attributed OCSF rows, JSONL parity 50/50, BuffersLost=0, clean start/stop (no false failure). Signed-off-by: Akber Raza <[email protected]> * feat(mxc-ocsf): add ETW->OCSF audit-trail example kit; fix proxy-configured message Add a runnable OCSF audit-trail example under examples/ (run-ocsf-audit.ps1, mxc-ocsf-audit.toml, ocsf-audit.yaml, README) that spins up sandboxes with the in-process ETW consumer and egress proxy on, emitting a full OCSF JSONL audit trail across all four classes (6002/5019/1007/2004). Fix SandboxProxyConfigured mapping to log "MXC sandbox proxy configured" instead of a misleading "(no proxy)" when the provider reports proxyPort=0; the event's presence already indicates proxy configuration. Verified on-box: 26 events, all mapped ETW event types present. Signed-off-by: Akber Raza <[email protected]> * feat(mxc-ocsf): clearer audit report + client-safe run-ocsf-audit.ps1 Improve the ETW to OCSF audit-trail example output and make it safe to ship. Report: - Add an event-type coverage count ("N of M expected event types fired"); the denominator auto-adjusts (8 with proxy on, 7 with -NoProxy). - Split the checklist into expected event types vs anomaly findings (ActivityError/FallbackError), which are reported separately and not counted toward coverage (a clean run may emit none). - Verdict is now coverage-based (all expected types must fire) instead of the looser "at least 3 OCSF classes". - Call out the absolute path to the durable OCSF JSONL log prominently. Client-safety: - Default -ShareOut to empty (no auto-copy); pass -ShareOut a UNC path to opt in. Removes a hardcoded internal share path from a published example. - Drop internal-team wording ("Hand that zip back for evaluation", "BUNDLE:") in favor of neutral "Results bundle:". - Update README-ocsf-audit.txt to match the opt-in -ShareOut behavior. Verified on both MXC boxes: 7F203-MXC-001 (base-container) -> PASS, 8 of 8 event types, 26 OCSF events across 4 classes; 7F203-MXC-003 (AppContainer fallback) -> reduced set as expected, clean output. Signed-off-by: Akber Raza <[email protected]> * fix(mxc): configure OCSF audit workloads per sandbox - remove unsupported gateway-scoped workload fields from the shipped MXC audit example. - build the command, working directory, and filesystem grant from each run's ShareDir - pass the workload through --driver-config-json. - preserve the host CONNECT proxy configuration and conditional audit coverage for the future host_connect_proxy merge - require the workload output when determining the audit verdict. Signed-off-by: Akber Raza <[email protected]> * fix(mxc): omit command arguments from OCSF audit logs - record only the executable basename for MXC CreateProcessInSandbox audit events - leave process.cmd_line unset so workload arguments cannot reach shorthand or JSONL logs - cover tokens, passwords, signed URLs, and PII with a secret-leak regression test - update the audit example, architecture guidance, and published logging documentation - preserve ETW attribution and future host_connect_proxy enforcement behavior Signed-off-by: Akber Raza <[email protected]> * feat(etw): enhance ETW session management with distinct naming for concurrent gateways * fix(etw): bound the audit queue during overload - replace the unbounded ETW callback channel with count- and byte-bounded buffering - keep the ETW callback non-blocking and count records rejected during overload - emit immediate, rate-limited warnings that identify resulting audit coverage gaps - make the audit example fail when queue overload causes dropped ETW records - cover stalled consumers, oversized events, and warning throttling with unit tests Signed-off-by: Akber Raza <[email protected]> * fix(etw): harden sandbox audit attribution - remove command-line and persistent per-PID fallback keys from live and replay resolution - retire the driver-owned wxc-exec PID before publishing child completion - retain established identity, activity, and correlation-vector links only for the five-second late-event window - prevent buffered records from crossing rapid PID retirement and reuse boundaries - add resolver and lifecycle coverage and document the attribution trust boundary Signed-off-by: Akber Raza <[email protected]> * chore(mxc): address rebase follow-ups Signed-off-by: Drew Newberry <[email protected]> * fix(mxc): align OCSF audit example with driver config - remove unsupported egress proxy settings - stop requiring the unavailable proxy audit event - update example documentation for supported event coverage Signed-off-by: Akber Raza <[email protected]> * fix(etw): redact command-line secrets in DecodedEtwEvent summary * fix(etw): enhance PID resolution and event attribution logic for ETW records * fix(ocsf): restrict gateway-local JSONL sink to Windows/MXC path with opt-in configuration * address rebase issues * fix(mxc): address ETW audit review feedback Signed-off-by: Drew Newberry <[email protected]> * fix(mxc): fail closed across ambiguous PID reuse Signed-off-by: Drew Newberry <[email protected]> * fix(mxc): bind ETW attribution to process generation Signed-off-by: Drew Newberry <[email protected]> --------- Signed-off-by: Akber Raza <[email protected]> Signed-off-by: Drew Newberry <[email protected]> Co-authored-by: Jamie King <[email protected]> Co-authored-by: Drew Newberry <[email protected]>
1 parent 0569c3a commit ae57979

21 files changed

Lines changed: 3568 additions & 31 deletions

File tree

‎Cargo.lock‎

Lines changed: 3 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,9 @@ terminal-colorsaurus = "1.0"
5454
# Error handling
5555
miette = { version = "7", features = ["fancy"] }
5656
thiserror = "2"
57+
58+
# Windows platform APIs (ETW/TDH audit consumer in openshell-driver-mxc; Windows-only)
59+
windows = { version = "0.62", features = ["Wdk_System_Threading", "Win32_Foundation", "Win32_System_Diagnostics_Etw", "Win32_System_Time"] }
5760
anyhow = "1"
5861

5962
# Logging/Tracing

‎architecture/security-policy.md‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -389,3 +389,19 @@ record for the same request.
389389

390390
Never log secrets, credentials, bearer tokens, or query parameters in OCSF
391391
messages. OCSF JSONL output may be shipped to external systems.
392+
The gateway-local OCSF JSONL file sink is restricted to the Windows/MXC path
393+
and requires an explicit `OPENSHELL_OCSF_JSON=1` opt-in. Other gateway
394+
deployments do not initialize this gateway file sink; a cross-platform gateway
395+
sink requires its own storage and configuration integration.
396+
MXC ETW process events record executable identity but omit command-line
397+
arguments from structured fields and messages. Raw ETW debug summaries replace
398+
the `commandLine` value with `[REDACTED]`, including pending-buffer eviction
399+
diagnostics.
400+
MXC ETW attribution never treats command text as ownership evidence. It uses the
401+
driver-owned `wxc-exec` PID plus its kernel process start key as the initial
402+
anchor. ETW attaches that generation key to each record, and the driver queries
403+
the same key from its child process handle. PID attribution requires both values
404+
to match, so reuse cannot transfer ownership between process generations.
405+
Retired PID evidence is discarded; established identity, activity, and
406+
correlation-vector links remain eligible during the five-second late-event
407+
window. Records without matching generation evidence fail closed.

‎crates/openshell-driver-mxc/Cargo.toml‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,10 @@ name = "openshell_driver_mxc"
1515

1616
[dependencies]
1717
openshell-core = { path = "../openshell-core", default-features = false }
18+
# OCSF builders + emit target used by the Windows ETW audit consumer. OS-agnostic
19+
# crate (no windows deps), so safe to depend on from all targets; only the
20+
# windows-gated `etw_consumer` module actually uses it.
21+
openshell-ocsf = { path = "../openshell-ocsf" }
1822
tokio = { workspace = true }
1923
tonic = { workspace = true }
2024
futures = { workspace = true }
@@ -26,6 +30,11 @@ tracing = { workspace = true }
2630
thiserror = { workspace = true }
2731
uuid = { workspace = true }
2832

33+
# ETW/TDH real-time consumer (Plane A audit). Windows-only so the Linux/WSL
34+
# build stays an empty stub.
35+
[target.'cfg(target_os = "windows")'.dependencies]
36+
windows = { workspace = true }
37+
2938
[dev-dependencies]
3039
tokio = { workspace = true }
3140
# tempfile is not a workspace dependency; 3.27 is already resolved in Cargo.lock.

‎crates/openshell-driver-mxc/README.md‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ default_configuration_id = "composable"
4242
pc_least_privilege = false
4343
pc_capabilities = []
4444
debug = false
45+
etw_audit = false
4546
```
4647

4748
Supply workload settings for each sandbox. The public config is keyed by driver name; the gateway forwards only the inner `mxc` object to the driver:
@@ -58,6 +59,33 @@ Network policy support depends on the selected containment path. Policy
5859
replacement and merge updates use the gateway's standard sandbox configuration
5960
revision contract.
6061

62+
When `etw_audit` is enabled, each gateway process owns a distinct real-time ETW
63+
session named from the stable `OpenShell-MXC-ETW` prefix, its process ID, and a
64+
per-start discriminator. Starting another gateway never stops an existing
65+
gateway's capture. Graceful shutdown stops the session by its owned handle. A
66+
force-killed gateway can leave a stale session; the audit example removes only
67+
matching sessions whose encoded owner process is no longer running.
68+
69+
The gateway-local OCSF JSONL sink is available only for the Windows/MXC path
70+
and is opt-in. Set `OPENSHELL_OCSF_JSON=1` to enable it and optionally set
71+
`OPENSHELL_OCSF_LOG_DIR` to override its `%PROGRAMDATA%\OpenShell\logs` default.
72+
Other gateway deployments do not initialize this local file sink.
73+
74+
The ETW callback uses a non-blocking queue capped at 4,096 records and 16 MiB
75+
of copied event data. Records that exceed either limit are dropped instead of
76+
blocking the ETW pump or growing gateway memory. The gateway emits an immediate
77+
warning identifying the audit coverage gap and rate-limits follow-up warnings
78+
to once every 30 seconds while overload continues.
79+
80+
Audit attribution bootstraps only when the driver-owned `wxc-exec` PID and its
81+
kernel process start key both match the values attached to the ETW record;
82+
command text is never an ownership key. This generation key prevents a recycled
83+
PID from inheriting the previous process's attribution regardless of delivery
84+
delay. The process monitor retires the live PID at exit. Established identity,
85+
activity, and correlation-vector links remain available for five seconds so
86+
already in-flight ETW records can arrive, but retired PID evidence cannot resolve
87+
them. Records without matching generation evidence remain unattributed.
88+
6189
## Prerequisites (live runs)
6290

6391
- Windows 11 Insider build ≥ 26300.8553
Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,74 @@
1+
OpenShell MXC - ETW -> OCSF audit-trail example
2+
===============================================
3+
4+
WHAT THIS PROVES / PRODUCES
5+
The full Windows OCSF audit path on this box:
6+
gateway -> MXC driver -> process_container sandbox
7+
-> the OS "Sandboxing" ETW provider fires as the sandbox is created
8+
-> the gateway's in-process consumer decodes each event, attributes it to
9+
an OpenShell sandbox_id, and maps it to OCSF
10+
-> events are written to a durable JSONL audit log AND printed as
11+
human-readable shorthand.
12+
13+
The deliverable is the OCSF log: openshell-ocsf.<date>.log, one OCSF event
14+
object per line - the same schema and medium the Linux OpenShell pipeline
15+
produces (Windows is at functional parity).
16+
17+
OCSF classes you will see:
18+
[6002] Application Lifecycle - sandbox created
19+
[5019] Device Config State Change - OS policy / hardening / console
20+
[1007] Process Activity - in-sandbox process launch (+ executable identity)
21+
[2004] Detection Finding - MXC setup activity errors (informational)
22+
23+
PREREQUISITES (on this test box)
24+
- wxc-exec.exe present (default expected: C:\mxc-kit\bin\wxc-exec.exe)
25+
- process_container backend live (it was for our earlier runs)
26+
- Run ELEVATED (Run as administrator) OR from an account in the
27+
'Performance Log Users' group. Opening the real-time ETW session needs this;
28+
without it the run fails fast with a clear message.
29+
30+
HOW TO RUN
31+
1. Open an ELEVATED PowerShell in THIS folder.
32+
2. Run:
33+
powershell -NoProfile -ExecutionPolicy Bypass -File .\run-ocsf-audit.ps1
34+
If wxc-exec is somewhere else:
35+
... -File .\run-ocsf-audit.ps1 -WxcExecPath "D:\path\to\wxc-exec.exe"
36+
37+
WHAT YOU GET BACK
38+
The script prints PASS/FAIL + an event-type coverage count and class breakdown,
39+
points you at the OCSF audit log, and creates:
40+
results-<timestamp>.zip
41+
It contains the OCSF audit log (openshell-ocsf.<date>.log), the full transcript,
42+
the gateway logs (with the human-readable OCSF shorthand), a summary, and the
43+
exact config + policy used. To auto-copy the bundle to a shared location, pass
44+
-ShareOut '\\server\share' (off by default; results stay local otherwise).
45+
46+
FILES IN THIS PACKAGE
47+
openshell-gateway.exe the gateway (self-contained; needs only VC++ runtime)
48+
openshell.exe the CLI
49+
mxc-ocsf-audit.toml gateway/driver config (process_container, etw_audit=true)
50+
ocsf-audit.yaml sandbox policy (read-write grant to the share dir)
51+
run-ocsf-audit.ps1 the orchestrator you run
52+
README-ocsf-audit.txt this file
53+
(wxc-exec.exe is used IN PLACE on the box; not shipped)
54+
55+
USEFUL OPTIONS
56+
-SandboxCount <n> Create n sandboxes (default 2). More sandboxes = more events.
57+
-ShareDir <path> Host folder granted read-write to the workload. The script
58+
derives a disposable policy and per-sandbox config for it.
59+
-WxcExecPath <path> Path to wxc-exec.exe on this box.
60+
-ShareOut <path> Copy the results bundle to a shared location
61+
(e.g. \\server\share). Off by default (results stay local).
62+
-KeepRunning Leave the gateway running afterward for inspection.
63+
64+
NOTES
65+
- The control plane between CLI and gateway runs with --disable-tls on loopback;
66+
that is unrelated to the OCSF audit path this example exercises.
67+
- A "supervisor session not connected" / ssh 255 message during sandbox create
68+
is EXPECTED on MXC and harmless - the agent already ran in-driver.
69+
- The Sandboxing provider reports the sandbox entry-point process, not the full
70+
in-sandbox process tree. Deep process-tree auditing would need a second ETW
71+
source (Microsoft-Windows-Kernel-Process) and is out of scope for this trail.
72+
- MXC process audit events record the executable basename only. Command-line
73+
arguments are omitted from OCSF JSON and shorthand because they can contain
74+
credentials, signed URLs, or PII.
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2+
# SPDX-License-Identifier: Apache-2.0
3+
4+
# MXC gateway config for the ETW -> OCSF audit-trail example.
5+
#
6+
# Goal: exercise the in-process ETW consumer (Plane A) end-to-end so that
7+
# creating a sandbox produces a full OCSF audit trail — Application Lifecycle
8+
# [6002], Device Config State Change [5019], Process Activity [1007] and
9+
# Detection Finding [2004] — written to a durable JSONL log, just like the Linux
10+
# OCSF pipeline.
11+
#
12+
# run-ocsf-audit.ps1 patches wxc_exec_path, backend, and etw_audit into a
13+
# disposable copy of this file. Workload command and cwd are sandbox-scoped and
14+
# passed separately through --driver-config-json.
15+
16+
[openshell.drivers.mxc]
17+
# Path to wxc-exec.exe on the box (patched by the run script; default is the
18+
# location observed on the MXC test boxes).
19+
wxc_exec_path = "C:\\mxc-kit\\bin\\wxc-exec.exe"
20+
21+
# One-shot AppContainer. This is the backend whose Sandboxing ETW the consumer
22+
# captures. (isolation_session is "dark" — it emits no provider events.)
23+
backend = "process_container"
24+
25+
default_configuration_id = "composable"
26+
27+
debug = false
28+
29+
# Turn ON the Plane-A ETW -> OCSF audit consumer. This is the core of the example.
30+
etw_audit = true
Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2+
# SPDX-License-Identifier: Apache-2.0
3+
4+
# ocsf-audit.yaml — sandbox policy for the MXC ETW -> OCSF audit-trail example.
5+
#
6+
# Minimal filesystem policy granting the workload folder read-write; everything
7+
# else is default-deny. run-ocsf-audit.ps1 copies this policy into the result
8+
# bundle and replaces the default grant with -ShareDir for that run.
9+
version: 1
10+
11+
filesystem_policy:
12+
include_workdir: false
13+
read_only: []
14+
read_write:
15+
- "C:/work/openshell-mxc-demo"

0 commit comments

Comments
 (0)