fix(process): stabilize native capture and ownership prerequisites
This commit is contained in:
@@ -323,31 +323,46 @@ def _wanted(spec, symbol):
|
||||
return symbol.startswith("-[" if method_type == "instance" else "+[")
|
||||
|
||||
|
||||
def _record(context, thread, index, sequence, location, remaining_bytes):
|
||||
def _read_register(frame, name):
|
||||
error = lldb.SBError()
|
||||
value = frame.FindRegister(name)
|
||||
if not value.IsValid():
|
||||
raise RuntimeError("LLDB breakpoint register %s is unavailable" % name)
|
||||
number = value.GetValueAsUnsigned(error)
|
||||
if error.Fail():
|
||||
raise RuntimeError(
|
||||
"LLDB breakpoint register %s could not be read: %s" % (name, error)
|
||||
)
|
||||
return number
|
||||
|
||||
|
||||
def _record(context, thread, frame, index, sequence, location, remaining_bytes):
|
||||
target, process, config = context["target"], context["process"], context["config"]
|
||||
frame = thread.GetFrameAtIndex(0)
|
||||
symbol = location["symbol"] or ""
|
||||
if not _wanted(config["breakpoints"][index], symbol):
|
||||
return None
|
||||
names = ARGUMENT_REGISTERS.get(config["architecture"], [])
|
||||
objc_method = symbol.startswith("-[") or symbol.startswith("+[")
|
||||
values = {
|
||||
name: _read_register(frame, name)
|
||||
for name in names[: max(config["argument_registers"], 2 if objc_method else 0)]
|
||||
}
|
||||
registers = [
|
||||
{"name": name, "value": _hex(frame.FindRegister(name).GetValueAsUnsigned())}
|
||||
{"name": name, "value": _hex(values[name])}
|
||||
for name in names[: config["argument_registers"]]
|
||||
]
|
||||
receiver_class = None
|
||||
selector = None
|
||||
if symbol.startswith("-[") or symbol.startswith("+["):
|
||||
if objc_method:
|
||||
error = lldb.SBError()
|
||||
text = process.ReadCStringFromMemory(
|
||||
frame.FindRegister(names[1]).GetValueAsUnsigned(),
|
||||
values[names[1]],
|
||||
MAX_SELECTOR_BYTES,
|
||||
error,
|
||||
)
|
||||
selector = text if error.Success() and text else None
|
||||
if symbol.startswith("-["):
|
||||
receiver_class = _dynamic_class(
|
||||
target, frame.FindRegister(names[0]).GetValueAsUnsigned()
|
||||
)
|
||||
receiver_class = _dynamic_class(target, values[names[0]])
|
||||
estimated_base = (
|
||||
_estimated_json_size(location)
|
||||
+ _estimated_json_size(receiver_class)
|
||||
@@ -370,79 +385,100 @@ def _record(context, thread, index, sequence, location, remaining_bytes):
|
||||
return record
|
||||
|
||||
|
||||
def _handle_stop(context, events, other_stops):
|
||||
"""Record breakpoint hits of one stop; return an outcome when tracing must end."""
|
||||
process = context["process"]
|
||||
for thread in process:
|
||||
reason = thread.GetStopReason()
|
||||
if reason == lldb.eStopReasonBreakpoint:
|
||||
index = context["breakpoint_index"].get(thread.GetStopReasonDataAtIndex(0))
|
||||
if index is None:
|
||||
continue
|
||||
frame = thread.GetFrameAtIndex(0)
|
||||
location = _location(frame.GetPCAddress(), context["target"])
|
||||
symbol = location["symbol"] or ""
|
||||
if not _wanted(context["config"]["breakpoints"][index], symbol):
|
||||
continue
|
||||
frame_count = max(
|
||||
0,
|
||||
min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]),
|
||||
)
|
||||
event_frame_count = 1 + frame_count
|
||||
if not _can_retain_trace(
|
||||
context["retained_trace_bytes"],
|
||||
context["retained_frames"],
|
||||
0,
|
||||
event_frame_count,
|
||||
):
|
||||
return "resource-limit"
|
||||
# One trace runs in each owned LLDB subprocess. Its callbacks execute at the
|
||||
# breakpoint before LLDB resumes, unlike snapshots of later public stop events.
|
||||
_TRACE_CONTEXT = None
|
||||
|
||||
|
||||
def _handle_breakpoint(context, frame, index):
|
||||
"""Read one hit while LLDB's breakpoint callback owns the stopped frame."""
|
||||
if not frame.IsValid() or frame.GetPC() == lldb.LLDB_INVALID_ADDRESS:
|
||||
raise RuntimeError("LLDB breakpoint callback did not supply a readable frame")
|
||||
thread = frame.GetThread()
|
||||
events = context["events"]
|
||||
location = _location(frame.GetPCAddress(), context["target"])
|
||||
symbol = location["symbol"] or ""
|
||||
if not _wanted(context["config"]["breakpoints"][index], symbol):
|
||||
return None
|
||||
frame_count = max(
|
||||
0,
|
||||
min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]),
|
||||
)
|
||||
event_frame_count = 1 + frame_count
|
||||
if not _can_retain_trace(
|
||||
context["retained_trace_bytes"],
|
||||
context["retained_frames"],
|
||||
0,
|
||||
event_frame_count,
|
||||
):
|
||||
return "resource-limit"
|
||||
try:
|
||||
remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"]
|
||||
record = _record(
|
||||
context, thread, frame, index, len(events), location, remaining_bytes
|
||||
)
|
||||
except ValueError:
|
||||
return "resource-limit"
|
||||
if record is not None:
|
||||
if not _fits_trace_budget(record, remaining_bytes):
|
||||
return "resource-limit"
|
||||
record_bytes = len(json.dumps(record).encode("utf-8"))
|
||||
if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES:
|
||||
return "resource-limit"
|
||||
for depth in range(1, frame_count + 1):
|
||||
try:
|
||||
remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"]
|
||||
record = _record(
|
||||
context, thread, index, len(events), location, remaining_bytes
|
||||
location = _location(
|
||||
thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"]
|
||||
)
|
||||
except ValueError:
|
||||
return "resource-limit"
|
||||
if record is not None:
|
||||
if not _fits_trace_budget(record, remaining_bytes):
|
||||
return "resource-limit"
|
||||
record_bytes = len(json.dumps(record).encode("utf-8"))
|
||||
if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES:
|
||||
return "resource-limit"
|
||||
for depth in range(1, frame_count + 1):
|
||||
try:
|
||||
location = _location(
|
||||
thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"]
|
||||
)
|
||||
except ValueError:
|
||||
return "resource-limit"
|
||||
if (
|
||||
_estimated_json_size(location) + record_bytes + 1
|
||||
> MAX_TRACE_BYTES - context["retained_trace_bytes"]
|
||||
):
|
||||
return "resource-limit"
|
||||
location_bytes = len(json.dumps(location).encode("utf-8"))
|
||||
addition = location_bytes + (1 if record["backtrace"] else 0)
|
||||
if (
|
||||
context["retained_trace_bytes"]
|
||||
+ record_bytes
|
||||
+ addition
|
||||
> MAX_TRACE_BYTES
|
||||
):
|
||||
return "resource-limit"
|
||||
record["backtrace"].append(location)
|
||||
record_bytes += addition
|
||||
journal = context.get("observation_journal")
|
||||
if journal is not None and not journal.append(
|
||||
{"kind": "event", "event": record}
|
||||
):
|
||||
return "resource-limit"
|
||||
events.append(record)
|
||||
context["retained_frames"] += event_frame_count
|
||||
context["retained_trace_bytes"] += record_bytes
|
||||
if len(events) >= context["config"]["max_events"]:
|
||||
return "event-limit"
|
||||
elif reason in (lldb.eStopReasonSignal, lldb.eStopReasonException):
|
||||
if (
|
||||
_estimated_json_size(location) + record_bytes + 1
|
||||
> MAX_TRACE_BYTES - context["retained_trace_bytes"]
|
||||
):
|
||||
return "resource-limit"
|
||||
location_bytes = len(json.dumps(location).encode("utf-8"))
|
||||
addition = location_bytes + (1 if record["backtrace"] else 0)
|
||||
if (
|
||||
context["retained_trace_bytes"]
|
||||
+ record_bytes
|
||||
+ addition
|
||||
> MAX_TRACE_BYTES
|
||||
):
|
||||
return "resource-limit"
|
||||
record["backtrace"].append(location)
|
||||
record_bytes += addition
|
||||
journal = context.get("observation_journal")
|
||||
if journal is not None and not journal.append(
|
||||
{"kind": "event", "event": record}
|
||||
):
|
||||
return "resource-limit"
|
||||
events.append(record)
|
||||
context["retained_frames"] += event_frame_count
|
||||
context["retained_trace_bytes"] += record_bytes
|
||||
if len(events) >= context["config"]["max_events"]:
|
||||
return "event-limit"
|
||||
return None
|
||||
|
||||
|
||||
def breakpoint_hit(frame, location, internal_dict):
|
||||
"""LLDB callback: capture before resuming, and stop on a limit or failure."""
|
||||
context = _TRACE_CONTEXT
|
||||
if context is None or context["outcome"] is not None or context["failure"] is not None:
|
||||
return True
|
||||
try:
|
||||
index = context["breakpoint_index"][location.GetBreakpoint().GetID()]
|
||||
context["outcome"] = _handle_breakpoint(context, frame, index)
|
||||
except Exception as error:
|
||||
context["failure"] = "%s: %s" % (type(error).__name__, error)
|
||||
return True
|
||||
return context["outcome"] is not None
|
||||
|
||||
|
||||
def _handle_stop(context, other_stops):
|
||||
"""Retain non-breakpoint stop observations; callbacks already capture hits."""
|
||||
for thread in context["process"]:
|
||||
if thread.GetStopReason() in (lldb.eStopReasonSignal, lldb.eStopReasonException):
|
||||
stop_description = thread.GetStopDescription(256)
|
||||
journal = context.get("observation_journal")
|
||||
if journal is not None and not journal.append(
|
||||
@@ -510,7 +546,17 @@ def _wait_for_exit(listener, process, seconds):
|
||||
listener.WaitForEvent(1, event)
|
||||
|
||||
|
||||
def _failed_launch_description(process):
|
||||
if process.GetState() != lldb.eStateExited or process.GetExitStatus() != -1:
|
||||
return None
|
||||
description = process.GetExitDescription()
|
||||
if isinstance(description, str) and description.lower().startswith(("attach failed", "launch failed")):
|
||||
return description
|
||||
return None
|
||||
|
||||
|
||||
def trace(debugger, config):
|
||||
global _TRACE_CONTEXT
|
||||
debugger.SetAsync(True)
|
||||
# Stop at the symbol itself, where argument registers still hold the ABI
|
||||
# arguments, even when line tables would let LLDB skip the prologue.
|
||||
@@ -577,6 +623,11 @@ def trace(debugger, config):
|
||||
stdout.close()
|
||||
stderr.close()
|
||||
return {"status": "launch-error", "error": error.GetCString()}
|
||||
launch_failure = _failed_launch_description(process)
|
||||
if launch_failure is not None:
|
||||
stdout.close(expected_exit=True)
|
||||
stderr.close(expected_exit=True)
|
||||
return {"status": "launch-error", "error": launch_failure}
|
||||
stdout.mark_launched()
|
||||
stderr.mark_launched()
|
||||
# Publish the PID before any post-launch file or module inspection. The
|
||||
@@ -650,6 +701,11 @@ def trace(debugger, config):
|
||||
"observation_journal": observation_journal,
|
||||
}
|
||||
events = []
|
||||
context.update({"events": events, "outcome": None, "failure": None})
|
||||
_TRACE_CONTEXT = context
|
||||
for breakpoints in created:
|
||||
for breakpoint in breakpoints:
|
||||
breakpoint.SetScriptCallbackFunction("rea_lldb_tracer.breakpoint_hit")
|
||||
other_stops = []
|
||||
outcome = None
|
||||
deadline = started + config["duration_ms"] / 1000
|
||||
@@ -670,7 +726,9 @@ def trace(debugger, config):
|
||||
if state == lldb.eStateExited:
|
||||
outcome = "exited"
|
||||
elif state == lldb.eStateStopped and not lldb.SBProcess.GetRestartedFromEvent(event):
|
||||
outcome = _handle_stop(context, events, other_stops)
|
||||
if context["failure"] is not None:
|
||||
raise RuntimeError(context["failure"])
|
||||
outcome = context["outcome"] or _handle_stop(context, other_stops)
|
||||
if outcome is None:
|
||||
process.Continue()
|
||||
pid = process.GetProcessID()
|
||||
@@ -685,6 +743,12 @@ def trace(debugger, config):
|
||||
process_exited = process.GetState() == lldb.eStateExited
|
||||
stdout.close(expected_exit=process_exited)
|
||||
stderr.close(expected_exit=process_exited)
|
||||
# SBTarget.Launch may succeed before debugserver reports an asynchronous
|
||||
# attach failure as an exited SBProcess. Its -1 status is not a target
|
||||
# exit code; preserve the debugger's concrete launch denial.
|
||||
launch_failure = _failed_launch_description(process)
|
||||
if launch_failure is not None:
|
||||
return {"status": "launch-error", "error": launch_failure}
|
||||
launch_identity_stable = (
|
||||
module_path_before is not None
|
||||
and module_path_after == module_path_before
|
||||
@@ -733,6 +797,7 @@ def trace(debugger, config):
|
||||
}
|
||||
|
||||
finally:
|
||||
_TRACE_CONTEXT = None
|
||||
if observation_journal is not None:
|
||||
try:
|
||||
observation_journal.handle.close()
|
||||
|
||||
@@ -152,7 +152,14 @@ private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation {
|
||||
}
|
||||
bytes = Array(bytes.prefix(size))
|
||||
do {
|
||||
return RunTokenObservation(pid: pid, state: "readable", run_id: try token(in: bytes, pointerSize: pointerSize), reason: nil)
|
||||
let runId = try token(in: bytes, pointerSize: pointerSize)
|
||||
// A complete empty environment is readable for an ordinary image. Apple
|
||||
// platform images can expose the same layout after the kernel withholds
|
||||
// their environment, so they remain explicitly unverified without a token.
|
||||
if runId == nil && isPlatformBinary(pid: pid) {
|
||||
return unavailable(pid: pid, reason: "platform_binary_environment_withheld")
|
||||
}
|
||||
return RunTokenObservation(pid: pid, state: "readable", run_id: runId, reason: nil)
|
||||
} catch RunTokenReadError.duplicateToken {
|
||||
return unavailable(pid: pid, reason: "duplicate_run_token")
|
||||
} catch RunTokenReadError.invalidTokenEncoding {
|
||||
@@ -259,9 +266,6 @@ func token(in bytes: [UInt8], pointerSize: Int = MemoryLayout<UnsafeRawPointer>.
|
||||
throw RunTokenReadError.ambiguousEnvironmentBoundary
|
||||
}
|
||||
let environmentEntries = trailingEntries[..<appleVectorStart]
|
||||
guard !environmentEntries.isEmpty else {
|
||||
throw RunTokenReadError.environmentUnavailable
|
||||
}
|
||||
var found: String?
|
||||
for entry in environmentEntries {
|
||||
if entry.starts(with: Array("REA_PROCESS_RUN_ID=".utf8)) {
|
||||
|
||||
+13
-3
@@ -700,13 +700,18 @@ conformance/vtable fixture.
|
||||
process and helper. These lanes require an interactive macOS desktop. See [native investigation](native-investigation.md)
|
||||
|
||||
`npm run verify:native-calls` needs macOS with Command Line Tools (`clang`,
|
||||
`lldb`, `codesign`, `nm`) and Developer Mode enabled for unattended debugger
|
||||
access. Preflight reports disabled Developer Mode without changing host settings.
|
||||
`lldb`, `codesign`, `nm`) and actual debugger access to the owned fixtures.
|
||||
The lane reports Developer Mode status without treating it as proof of access
|
||||
or denial, and does not change host settings. LLDB and target entitlements
|
||||
establish the tested permission boundary.
|
||||
It compiles `tests/conformance/native/calls.m` and
|
||||
runs `observe-native-calls` through the CLI and stdio MCP. It checks:
|
||||
|
||||
- the receiver class, selector and argument registers of every entry, and that
|
||||
breakpoint addresses equal `nm`'s symbol addresses;
|
||||
- overlapping breakpoint selections retain each selection's hits and share
|
||||
the aggregate event limit; callback capture reads the stopped frame before
|
||||
LLDB resumes, avoiding stale frame metadata from asynchronous stop events;
|
||||
- captured stdout and an environment override, plus a 2 MiB flood on each
|
||||
output stream with bounded retained prefixes and exact drained-byte counts;
|
||||
- the event-limit and duration outcomes, with the process confirmed gone;
|
||||
@@ -715,10 +720,15 @@ runs `observe-native-calls` through the CLI and stdio MCP. It checks:
|
||||
|
||||
### Firmware adapters
|
||||
|
||||
Linux-owned provider launches require a procps-compatible `ps` on REA's `PATH`
|
||||
so ownership can be inspected before launching a child. A missing or incompatible
|
||||
command fails with an actionable capability error before the launch.
|
||||
|
||||
`npm run fixtures:firmware` uses existing Python 3 and a host C compiler to make
|
||||
an ignored gzip/USTAR firmware fixture and independent offset/hash oracle.
|
||||
`npm run verify:firmware` requires caller-supplied Binwalk 3.1.0, Unblob 26.6.4
|
||||
and util-linux prlimit on Linux. The provider also accepts other 3.1.x and
|
||||
and util-linux prlimit on Linux, with `7z` on `PATH` for the gzip/USTAR
|
||||
fixture's Unblob extractor. The provider also accepts other 3.1.x and
|
||||
26.6.x builds and reports them as unverified; this lane proves the audited
|
||||
releases. It verifies CLI/MCP parity, selected ranges,
|
||||
unknown chunks, depth limits and extracted child digests. The optional
|
||||
|
||||
@@ -160,6 +160,24 @@ try {
|
||||
if (mode === "mcp") assert.deepEqual(value.result, report);
|
||||
return report;
|
||||
};
|
||||
const ownershipProbe = join(root.path, "ownership-prerequisite.hex");
|
||||
await writeFile(ownershipProbe, "0x00");
|
||||
const missingInspection = await inspect(
|
||||
"cli",
|
||||
ownershipProbe,
|
||||
"hex",
|
||||
"unsupported_provider",
|
||||
{
|
||||
command: process.execPath,
|
||||
prefix: [],
|
||||
client,
|
||||
environment: { ...environment, PATH: root.path },
|
||||
},
|
||||
);
|
||||
assert.equal(missingInspection.code, "capability_unavailable");
|
||||
assert.match(missingInspection.message, /procps-compatible ps/u);
|
||||
assert.equal(missingInspection.details.operation, "prepare_owned_process");
|
||||
cases++;
|
||||
for (const [name, optimizer, viaIR] of [
|
||||
["plain", false, false],
|
||||
["optimized", true, false],
|
||||
|
||||
@@ -28,13 +28,6 @@ for (const tool of ["clang", "lldb", "codesign", "nm"])
|
||||
);
|
||||
}
|
||||
const developerMode = await exec("/usr/sbin/DevToolsSecurity", ["-status"]);
|
||||
if (
|
||||
!/enabled/iu.test(developerMode.stdout) ||
|
||||
/disabled/iu.test(developerMode.stdout)
|
||||
)
|
||||
throw new Error(
|
||||
"Native call observation verification requires macOS Developer Mode; DevToolsSecurity reports it disabled.",
|
||||
);
|
||||
|
||||
const SOURCE = fileURLToPath(
|
||||
new URL("../tests/conformance/native/calls.m", import.meta.url),
|
||||
@@ -51,6 +44,8 @@ const INPUT = {
|
||||
{ kind: "function", name: "rea_call_add" },
|
||||
],
|
||||
environment: { REA_CALLS_MARKER: "observed" },
|
||||
// Entry stops and Objective-C runtime reads slow the real target on busy hosts.
|
||||
duration_ms: 30_000,
|
||||
argument_registers: 4,
|
||||
backtrace_frames: 1,
|
||||
};
|
||||
@@ -59,6 +54,7 @@ const CLI_TIMEOUT_MS = 180_000;
|
||||
/** Pointer-free facts that two runs of the same scenario must share. */
|
||||
const stable = (result) =>
|
||||
result.events.map((event) => ({
|
||||
breakpoint_index: event.breakpoint_index,
|
||||
symbol: event.symbol,
|
||||
file_address: event.file_address,
|
||||
selector: event.selector,
|
||||
@@ -159,8 +155,7 @@ const checkBounds = async (binary) => {
|
||||
binary,
|
||||
[
|
||||
JSON.stringify({
|
||||
breakpoints: [{ kind: "function", name: "nanosleep" }],
|
||||
arguments: ["--wait"],
|
||||
breakpoints: [{ kind: "function", name: "rea_call_add" }],
|
||||
max_events: 2,
|
||||
duration_ms: 30_000,
|
||||
}),
|
||||
@@ -189,8 +184,9 @@ const checkBounds = async (binary) => {
|
||||
};
|
||||
|
||||
const cliFailure = async (binary) => {
|
||||
let output;
|
||||
try {
|
||||
await exec(
|
||||
const completed = await exec(
|
||||
process.execPath,
|
||||
[
|
||||
fileURLToPath(new URL("rea.mjs", import.meta.url)),
|
||||
@@ -204,10 +200,11 @@ const cliFailure = async (binary) => {
|
||||
timeout: CLI_TIMEOUT_MS,
|
||||
},
|
||||
);
|
||||
output = completed.stdout;
|
||||
} catch (cause) {
|
||||
return JSON.parse(cause.stdout);
|
||||
}
|
||||
throw new Error("observe-native-calls unexpectedly succeeded");
|
||||
throw new Error(`observe-native-calls unexpectedly succeeded: ${output}`);
|
||||
};
|
||||
|
||||
/** Hardened runtime blocks the debugger unless get-task-allow is granted. */
|
||||
@@ -226,6 +223,22 @@ const checkHardenedRuntime = async (directory, binary) => {
|
||||
const denied = await cliFailure(blocked);
|
||||
assert.equal(denied.code, "capability_unavailable");
|
||||
assert.match(denied.details.reason, /^debugger-attach-denied: /u);
|
||||
await withArtifactMcp(blocked, async (client) => {
|
||||
const deniedMcp = await client.callTool(
|
||||
{
|
||||
name: "observe_native_calls",
|
||||
arguments: INPUT,
|
||||
},
|
||||
{ timeout: CLI_TIMEOUT_MS },
|
||||
);
|
||||
assert.equal(deniedMcp.isError, true, JSON.stringify(deniedMcp));
|
||||
assert.equal(deniedMcp.structuredContent.error.code, denied.code);
|
||||
assert.match(
|
||||
deniedMcp.structuredContent.error.details.reason,
|
||||
/^debugger-attach-denied: /u,
|
||||
);
|
||||
assert.ok(deniedMcp.structuredContent.error.details.partial_observation);
|
||||
});
|
||||
const allowed = join(directory, "debuggable");
|
||||
const entitlements = join(directory, "get-task-allow.plist");
|
||||
await writeFile(
|
||||
@@ -267,14 +280,55 @@ try {
|
||||
"observe_native_calls",
|
||||
INPUT,
|
||||
);
|
||||
assert.equal(
|
||||
viaMcp.process.outcome,
|
||||
"exited",
|
||||
JSON.stringify(viaMcp.coverage),
|
||||
);
|
||||
assert.deepEqual(stable(viaMcp), stable(viaCli));
|
||||
assert.equal(viaMcp.process.stdout.text, viaCli.process.stdout.text);
|
||||
|
||||
// Two caller selections may resolve to one address. Each must retain its
|
||||
// own hit; consuming only the first stop-reason ID loses the second.
|
||||
const overlapping = {
|
||||
breakpoints: [
|
||||
{ kind: "function", name: "rea_call_add" },
|
||||
{ kind: "function", name: "rea_call_add", module: basename(binary) },
|
||||
],
|
||||
duration_ms: 30_000,
|
||||
argument_registers: 2,
|
||||
};
|
||||
const paired = await artifactMcpResult(
|
||||
client,
|
||||
"observe_native_calls",
|
||||
overlapping,
|
||||
);
|
||||
assert.equal(paired.process.outcome, "exited");
|
||||
assert.equal(paired.events.length, 6);
|
||||
for (const index of [0, 1]) {
|
||||
const hits = paired.events.filter(
|
||||
(event) => event.breakpoint_index === index,
|
||||
);
|
||||
assert.deepEqual(
|
||||
hits.map((event) => event.registers[0].value),
|
||||
["0x0", "0x1", "0x2"],
|
||||
);
|
||||
assert.ok(hits.every((event) => event.symbol === "rea_call_add"));
|
||||
}
|
||||
const capped = await artifactMcpResult(client, "observe_native_calls", {
|
||||
...overlapping,
|
||||
max_events: 2,
|
||||
});
|
||||
assert.equal(capped.process.outcome, "event-limit");
|
||||
assert.equal(capped.events.length, 2);
|
||||
assert.equal(capped.process.terminated, true);
|
||||
});
|
||||
await checkBounds(binary);
|
||||
await checkHardenedRuntime(directory, binary);
|
||||
console.log(
|
||||
JSON.stringify({
|
||||
ok: true,
|
||||
developer_mode: developerMode.stdout.trim(),
|
||||
mocked: false,
|
||||
cli: true,
|
||||
stdio_mcp: true,
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { execFile, spawn } from "node:child_process";
|
||||
import assert from "node:assert/strict";
|
||||
import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
@@ -7,6 +8,8 @@ import { promisify } from "node:util";
|
||||
import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import { observeNativeUi } from "../dist/native/NativeUiObservation.js";
|
||||
import { NATIVE_UI_HELPER_MAX_BUFFER } from "../dist/native/NativeUiOutputBudget.js";
|
||||
import { artifactMcpResult, withArtifactMcp } from "./lib/artifact-e2e.mjs";
|
||||
import { observeProcessStartIdentity } from "../dist/process/ProcessOwnershipObservation.js";
|
||||
|
||||
if (process.platform !== "darwin")
|
||||
throw new Error(
|
||||
@@ -14,7 +17,9 @@ if (process.platform !== "darwin")
|
||||
);
|
||||
const root = await mkdtemp(join(tmpdir(), "rea-ui-fixture-"));
|
||||
let child;
|
||||
let childExit;
|
||||
let fixturePid;
|
||||
let fixtureIdentity;
|
||||
let report;
|
||||
try {
|
||||
const childRetrievalTest = join(root, "child-retrieval-test");
|
||||
@@ -89,6 +94,7 @@ try {
|
||||
["-W", "-n", "-g", "--stdout", coordinates, join(root, "Fixture.app")],
|
||||
{ stdio: "ignore" },
|
||||
);
|
||||
childExit = new Promise((resolve) => child.once("exit", resolve));
|
||||
let scope;
|
||||
const deadline = Date.now() + 20000;
|
||||
while (Date.now() < deadline) {
|
||||
@@ -104,6 +110,12 @@ try {
|
||||
"Source-owned UI fixture failed to expose one window within 20 seconds",
|
||||
);
|
||||
fixturePid = scope.pid;
|
||||
fixtureIdentity = await observeProcessStartIdentity(fixturePid);
|
||||
assert.equal(
|
||||
fixtureIdentity?.state,
|
||||
"readable",
|
||||
"Fixture OS start identity is unavailable",
|
||||
);
|
||||
const target = await parseBinaryTarget(executable);
|
||||
if (!target.ok) throw target.error;
|
||||
const observation = await observeNativeUi(target.value, "observe_native_ui", {
|
||||
@@ -180,6 +192,43 @@ try {
|
||||
`Native UI CLI did not preserve the selected scenario: ${JSON.stringify(evidence.error ?? evidence.normalized_result?.steps?.map(({ outcome, reason }) => ({ outcome, reason })))}`,
|
||||
);
|
||||
scenarioStatus = "selected-AX-button-action-and-CLI-parity-observed";
|
||||
await withArtifactMcp(executable, async (client) => {
|
||||
const observed = await artifactMcpResult(client, "observe_native_ui", {
|
||||
...scope,
|
||||
screenshot: false,
|
||||
});
|
||||
if (
|
||||
!observed.initial.nodes.some(
|
||||
(node) =>
|
||||
node.role === "AXButton" &&
|
||||
JSON.stringify(node.path) === JSON.stringify(button.path),
|
||||
)
|
||||
)
|
||||
throw new Error("MCP omitted the selected fixture's actual AX button");
|
||||
const captured = await artifactMcpResult(
|
||||
client,
|
||||
"capture_native_ui_scenario",
|
||||
{
|
||||
...scope,
|
||||
screenshot: false,
|
||||
steps: [
|
||||
{ kind: "click", path: button.path },
|
||||
{ kind: "wait", milliseconds: 200 },
|
||||
],
|
||||
},
|
||||
);
|
||||
if (
|
||||
captured.steps.length !== 2 ||
|
||||
captured.steps.some((step) => step.outcome !== "completed") ||
|
||||
!captured.steps
|
||||
.at(-1)
|
||||
?.after?.nodes.some(
|
||||
(node) => node.title === "REA fixture incremented",
|
||||
)
|
||||
)
|
||||
throw new Error("MCP did not observe the selected fixture's AX action");
|
||||
});
|
||||
scenarioStatus = "selected-AX-button-action-and-CLI-MCP-parity-observed";
|
||||
}
|
||||
const mismatch = await observeNativeUi(
|
||||
{ ...target.value, sha256: "0".repeat(64) },
|
||||
@@ -201,17 +250,24 @@ try {
|
||||
target_owned: true,
|
||||
};
|
||||
} finally {
|
||||
if (fixturePid !== undefined) {
|
||||
try {
|
||||
process.kill(fixturePid, "SIGTERM");
|
||||
} catch (error) {
|
||||
if (error.code !== "ESRCH") throw error;
|
||||
if (fixturePid !== undefined && fixtureIdentity?.state === "readable") {
|
||||
const current = await observeProcessStartIdentity(fixturePid);
|
||||
if (current !== undefined) {
|
||||
assert.ok(
|
||||
current.state === "readable" &&
|
||||
current.identity === fixtureIdentity.identity,
|
||||
"Fixture PID identity changed; refusing to signal another process",
|
||||
);
|
||||
try {
|
||||
process.kill(fixturePid, "SIGTERM");
|
||||
} catch (cause) {
|
||||
if (cause.code !== "ESRCH") throw cause;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (child !== undefined && child.exitCode === null) {
|
||||
const exited = new Promise((resolve) => child.once("exit", resolve));
|
||||
child.kill("SIGTERM");
|
||||
await exited;
|
||||
await childExit;
|
||||
}
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
@@ -36,6 +36,14 @@ for (const variable of ["REA_BINWALK_COMMAND", "REA_UNBLOB_COMMAND"]) {
|
||||
);
|
||||
await access(path);
|
||||
}
|
||||
try {
|
||||
await exec("7z", ["i"], { timeout: 10_000 });
|
||||
} catch (cause) {
|
||||
throw new Error(
|
||||
"verify:firmware prerequisite unavailable: Unblob's gzip/USTAR fixture extraction requires 7z on PATH",
|
||||
{ cause },
|
||||
);
|
||||
}
|
||||
const fixtureRoot = resolve(
|
||||
process.env.REA_FIRMWARE_FIXTURE_ROOT ??
|
||||
join(repository, "_reference/firmware-integration/generated"),
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { readFile } from "node:fs/promises";
|
||||
import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
|
||||
|
||||
import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js";
|
||||
import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js";
|
||||
@@ -300,6 +301,22 @@ export const createSystemProcessOwnershipHost = (
|
||||
platform,
|
||||
prepare: async (signal) => {
|
||||
await darwinTokens?.prepare(signal);
|
||||
if (platform === "linux") {
|
||||
try {
|
||||
const processes = await listProcesses(signal);
|
||||
if (!processes.some(({ pid }) => pid === process.pid))
|
||||
throw new Error("ps did not report REA's current process");
|
||||
} catch (cause: unknown) {
|
||||
if (isExpectedAbort(cause, signal)) throw cause;
|
||||
const reason = `Linux process ownership inspection requires a procps-compatible ps on REA's PATH before launching a child: ${errorMessage(cause)}`;
|
||||
throw new AnalysisCapabilityUnavailableError(
|
||||
"process-ownership",
|
||||
"prepare_owned_process",
|
||||
reason,
|
||||
{ cause, userMessage: reason },
|
||||
);
|
||||
}
|
||||
}
|
||||
},
|
||||
listProcesses,
|
||||
async environment(pid) {
|
||||
|
||||
@@ -548,7 +548,6 @@ it.skipIf(!onDarwin)(
|
||||
clearedAppleVectorTokenFailsClosed: true,
|
||||
callerPfzBeforeTokenRead: true,
|
||||
emptyLaterArgumentRead: true,
|
||||
emptyEnvironmentFailsClosed: true,
|
||||
emptyArgv0Read: true,
|
||||
emptyEnvironmentRecordsBeforeTokenFailClosed: true,
|
||||
duplicateTokenFailsClosed: true,
|
||||
@@ -677,7 +676,7 @@ it.skipIf(!onDarwin)(
|
||||
);
|
||||
|
||||
it.skipIf(!onDarwin)(
|
||||
"reads owned tokens with empty later arguments across executable path padding",
|
||||
"reads owned tokens across executable padding and distinguishes a real empty environment",
|
||||
async () => {
|
||||
const root = await mkdtemp(join(tmpdir(), "rea-process-token-padding-"));
|
||||
const host = createSystemProcessOwnershipHost("darwin");
|
||||
@@ -699,6 +698,7 @@ it.skipIf(!onDarwin)(
|
||||
),
|
||||
);
|
||||
}
|
||||
children.push(await startNodeChild({}));
|
||||
const processes = await host.listProcesses();
|
||||
const entries = children.map(({ pid }) => {
|
||||
const entry = processes.find((process) => process.pid === pid);
|
||||
@@ -710,6 +710,7 @@ it.skipIf(!onDarwin)(
|
||||
expect(children.map(({ pid }) => observations?.get(pid))).toEqual([
|
||||
{ state: "readable", runId: "synthetic-padding-0" },
|
||||
{ state: "readable", runId: "synthetic-padding-1" },
|
||||
{ state: "readable" },
|
||||
]);
|
||||
} finally {
|
||||
for (const { child } of children) await stopNodeChild(child);
|
||||
|
||||
@@ -4,6 +4,7 @@ let app = NSApplication.shared
|
||||
app.setActivationPolicy(.accessory)
|
||||
let window = NSWindow(contentRect: NSRect(x: 120, y: 120, width: 360, height: 180), styleMask: [.titled, .closable], backing: .buffered, defer: false)
|
||||
window.title = "REA source-owned UI verification"
|
||||
window.animationBehavior = .none
|
||||
final class FixtureController: NSObject {
|
||||
@objc func increment(_ sender: NSButton) { sender.title = "REA fixture incremented" }
|
||||
}
|
||||
@@ -13,7 +14,8 @@ button.title = "Increment REA fixture"
|
||||
button.target = controller
|
||||
button.action = #selector(FixtureController.increment(_:))
|
||||
window.contentView?.addSubview(button)
|
||||
window.orderFront(nil)
|
||||
window.makeKeyAndOrderFront(nil)
|
||||
app.activate(ignoringOtherApps: true)
|
||||
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
|
||||
let record = "{\"pid\":\(ProcessInfo.processInfo.processIdentifier),\"window_id\":\(window.windowNumber)}\n"
|
||||
FileHandle.standardOutput.write(Data(record.utf8))
|
||||
|
||||
@@ -132,13 +132,6 @@ struct ProcessRunTokenParserProbe {
|
||||
} catch RunTokenReadError.duplicateToken {
|
||||
duplicateTokenFailsClosed = true
|
||||
}
|
||||
let emptyEnvironmentFailsClosed: Bool
|
||||
do {
|
||||
_ = try token(in: fixture(arguments: ["/fixture/executable"], environment: []))
|
||||
emptyEnvironmentFailsClosed = false
|
||||
} catch RunTokenReadError.environmentUnavailable {
|
||||
emptyEnvironmentFailsClosed = true
|
||||
}
|
||||
let missingAppleBoundaryFailsClosed: Bool
|
||||
do {
|
||||
_ = try token(in: fixture(
|
||||
@@ -158,7 +151,6 @@ struct ProcessRunTokenParserProbe {
|
||||
"alternatePaddingRead": alternatePadding == "alternate-padding-token",
|
||||
"truncatedArgvFailsClosed": truncatedArgvFailsClosed,
|
||||
"duplicateTokenFailsClosed": duplicateTokenFailsClosed,
|
||||
"emptyEnvironmentFailsClosed": emptyEnvironmentFailsClosed,
|
||||
"missingAppleBoundaryFailsClosed": missingAppleBoundaryFailsClosed,
|
||||
"emptyArgv0Read": emptyArgv0Read == "empty-argv0-token",
|
||||
"finalAssignmentArgumentRead": finalAssignmentArgumentRead == "final-assignment-token",
|
||||
|
||||
Reference in New Issue
Block a user