An ARM STT_FUNC or STT_GNU_IFUNC value for Thumb code is the code
address with bit 0 set (AAELF32 symbol values), while an FDE initial
location is the even code address. inspect_elf_unwind_ranges matched
symbol values to FDE starts exactly, so a Thumb function described by an
.eh_frame FDE lost its name: the range was named by a local label or
mapping symbol from .symtab, or had no name when only .dynsym was left.
On ARM EABI such FDEs come mostly from hand-written assembly with .cfi
directives; compiled code unwinds through .ARM.exidx.
Clear bit 0 of ARM function and IFUNC symbol values before the lookup, as
the ELF initializer and Android JNI readers already do. Mapping symbols
and other machines keep their values.
On SPARC, symbol type 13 is STT_SPARC_REGISTER. An undefined entry of
that type declares use of the global register named by st_value and
may have an empty name (SPARC V9 ABI); it is not an import.
inspect-elf-dependencies listed each one as an unnamed import, recorded
a name_unreadable issue for its empty name, and marked coverage
partial. JNA's sunos-sparcv9 libjnidispatch.so (shipped in Eclipse
Installer) declares %g2 and %g3 this way and reported 47 imports, two
of them unnamed, with partial coverage.
parseImports now skips undefined type-13 entries when e_machine is
EM_SPARC, EM_SPARC32PLUS or EM_SPARCV9. Elsewhere type 13 is a
different processor-specific type and keeps today's row.
Validation (macOS arm64, Node 24.22.1):
- New parser regressions for machines 2, 18 and 43 (big-endian, 32-
and 64-bit) fail before this change; a non-SPARC control keeps the
unnamed row and partial coverage.
- ElfDependencyParser, ElfDependenciesProvider and ElfDependenciesView:
79 passed. Format, typecheck, lint and architecture guards pass.
- Real file: libjnidispatch.so now reports 45 imports, complete
coverage and no issues, matching the 45 named undefined dynamic
symbols llvm-nm lists.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The ENOTCONN classifier and direct-error regression landed in #11490.
Keep that implementation and add coverage for an HTTP listener error whose
parsed system code is ENOTCONN after its native cause is made opaque.
Group the direct and wrapped cases outside the runtime test function to
keep the existing function-size limit while retaining both assertions.
Related: #11362
Signed-off-by: Deepak Jain <deepujain@gmail.com>
The remediation for a refused ptrace seize said injection was unavailable
whatever the target. Frida's reason carries no errno, so REA cannot tell a
host that lacks PTRACE_SEIZE, such as PRoot-Distro, from a ptrace permission
policy that refused only the selected process. Sending the second case to
another host would be wrong.
Word the remediation as two possibilities. If other targets fail the same
way, run REA on a host with native ptrace support or use a remote Frida
server. Otherwise check the ptrace permissions that apply to this target. The
regression test now asserts the conditional wording and that the host-wide
claim is gone.
Refs #9103
Signed-off-by: Deepak Jain <deepujain@gmail.com>
When Frida cannot start tracing a target because its ptrace seize request
was refused, REA reported the generic "Choose another analysis or target"
remediation. On PRoot-Distro, which does not implement PTRACE_SEIZE, no
target can work, so that advice sent operators in the wrong direction while
device and process discovery kept succeeding.
Recognize Frida's "Unable to perform ptrace seize" reason in the Frida
provider's failure conversion and return a message and remediation that name
the refused request, say injection is unavailable whatever the target, and
point at a host with native ptrace support or a remote Frida server. The
remote-connect remediation moves into the same helper. Other Frida startup
failures keep the generic remediation, and incomplete cleanup still takes
precedence over both.
Refs #9103
Signed-off-by: Deepak Jain <deepujain@gmail.com>
A reviewer read the test and said it would still pass with `Uint32Array` back at
`ByteEntropyService.ts:258`. That was correct, and I verified it: reverting the counter to
`Uint32Array` left all four cases green. The test pinned the counter type but not the loop that
fills it, so nothing tied the service's census to the exact counter.
The two counting loops were copies of each other — `computeBlockEntropy` and the service each had
their own. They are one function now, `countByteValues(bytes, counts)`, whose `counts` parameter is
`Float64Array`. That makes the counter type part of the signature rather than a local decision: a
narrower bin is a compile error at the call site, which is the guarantee the test was pretending to
give.
With `const counts = new Uint32Array(256);` at that line:
src/application/binaryDiagnostics/ByteEntropyService.ts(282,36): error TS2345:
Argument of type 'Uint32Array<ArrayBuffer>' is not assignable to parameter of type
'Float64Array<ArrayBufferLike>'.
The tests changed to match what they can actually prove:
- a census that lands just under 2^32 and then crosses it in one more chunk, asserting the total
does not wrap;
- two chunks accumulating into one counter, matching how the service counts a stream, compared
against the same bytes counted as one run.
I did not attempt a 4 GiB fixture: the loop is called per chunk, so crossing the boundary with a
counter set near it exercises the same arithmetic without a quarter-hour of I/O.
`src/domain/native/byteEntropy.test.ts` — 5 cases. `tsc` 0 errors.
The previous commit moved the whole-file census into a `Uint32Array`. That bin wraps
at 2^32 occurrences of one byte, and the service admits files up to
`Number.MAX_SAFE_INTEGER`, so a 6 GiB zero-filled file reported
`entropyFromCounts(counts, size)` = 0.5283 instead of 0.
Measured on 8 MiB, three interleaved runs against the compiled counter:
| form | time |
| --- | --- |
| `for...of` + `Float64Array` | 79.59ms |
| indexed + `Float64Array` | 9.26ms |
| indexed + `Uint32Array` | 9.28ms |
The 8x comes from the indexed reads, not from the integer bin, so exactness costs
nothing here. The bounded block counter stays bounded by `block_size` (max 65536) and
also uses a `Float64Array` so the two counters read the same.
`wholeFileByteCounts` names the counter the service uses, so the test can assert the
property that matters: a count above 2^32 survives. It fails on the previous commit.
`src/domain/native` + `src/application/binaryDiagnostics`: 443 passing. One test fails
on this Windows host before and after this diff — `reports a changed artifact when its
parent directory moves during streaming` fails with `ENOENT` on a directory rename.
`tsc` 0; `npm run lint` 0 errors; `knip` 0.
Both entropy counters walked the payload with `for (const byte of bytes)` and
accumulated into a `Float64Array` through `counts[byte] ?? 0`. Iterating a typed
array that way costs far more than an indexed read, and the nullish fallback is dead
work because a typed-array element is never `undefined`.
Measured on the compiled function with a 4 MiB block, alternating the two bodies so
both run in the same process:
| body | time |
| --- | --- |
| `for...of` + `Float64Array` | 37.15ms |
| indexed + `Uint32Array` | 4.64ms |
That is **8.01x** on the counter. Entropy values are unchanged: 300 randomised and
boundary inputs produce identical results to the previous implementation, and the
4 MiB fixture reports the same entropy from both bodies.
`ByteEntropyService` streams the same accounting over each read buffer, so it gets
the same change; `filled` bounds that loop because the buffer is reused between
reads.
`src/domain/native` and `src/application/binaryDiagnostics`: 442 passing. One test
fails on this Windows host in both the base and this diff — `reports a changed
artifact when its parent directory moves during streaming` fails with `ENOENT` on a
directory rename, so it is environmental, not caused by this change. `tsc` 0;
`npm run lint` 0 errors; `knip` 0.
A review finding, measured on Node 24.22.1. `_` is an RFC 9110 `tchar`, and the class I wrote
omitted it, so a valid method was reported as refused:
| call | outcome |
| --- | --- |
| `http.request({method: "M_SEARCH"})` | request constructed |
| `http.request({method: "X_CUSTOM"})` | request constructed |
| `http.request({method: "_"})` | request constructed |
| `http.request({method: "M-SEARCH"})` | request constructed |
| `http.request({method: "A B"})` | THREW `ERR_INVALID_HTTP_TOKEN` |
The class now matches RFC 9110 exactly. Three cases pin the characters a hand-written class is
most likely to drop: `_`, and the `-` that was already present.
`src/domain/javascript`: 5665 passing.
`http`/`https` validate `options.method` with `checkIsHttpToken` before the request exists, so a
literal outside the RFC 9110 token class throws `ERR_INVALID_HTTP_TOKEN` and no request is
created. The analyzer reported one anyway.
Measured on Node 24.22.1:
| call | outcome |
| --- | --- |
| `http.request({method: "BAD METHOD"})` | THREW `ERR_INVALID_HTTP_TOKEN` |
| `http.request({method: "GET"})`, `{method: "POST"}` | request constructed |
| `http.request({method: ""})` | request constructed — empty is a valid token, Node falls back to GET |
| `http.request("http://h/", {method: "BAD METHOD"})` | THREW |
| `http.request(new URL("http://h/"), {method: "BAD METHOD"})` | THREW |
## What this decides, and what it deliberately does not
Only shapes where the copied value is certainly the syntactic one:
- slot 0 is an options literal, or
- slot 0 is a string, a template or a verified `new URL`, so the `(url, options)` overload is proven
Every other shape keeps the request. Each of these was measured and can put something else in the
slot or change the copied value:
| call | outcome | why undecided here |
| --- | --- | --- |
| `http.request(() => {}, {method: "BAD METHOD"})` | request constructed | slot 0 is the callback, slot 1 unread |
| `https.request(null, {method: "BAD METHOD"})` | request constructed | `https` keeps its default options for a falsy input |
| `{get x() { this.method = "GET"; }, method: "BAD METHOD"}` | request constructed | the getter runs before the copy |
| `{method: "BAD METHOD", get x() { this.method = "GET"; }}` | THREW | getter after the copy cannot rescue it, but this reader does not model copy order |
| `{...{host: "h"}, method: "BAD METHOD"}` | THREW | a spread may replace the member |
The last two are the honest gap in this change. Closing them needs `Object.assign`'s enumeration
order — integer keys first, first-insertion position for a redefined key — which is a different
piece of work and belongs in its own change rather than widening this one.
Keeping a request Node never makes is the safer direction, and it is the direction I chose
wherever the copy is not certainly the literal.
## Contract and boundary impact
- Semantic owner and earliest changed stage: request candidate collection in the JavaScript domain.
- CLI and MCP/tool-catalog contract: none.
- Provider, bridge, target-format, or platform compatibility: `fetch` and `WebSocket` keep their
existing behavior; both use a different member and do not validate a token.
- Evidence, artifact, provenance, or reconstruction contract: a refused call no longer reports a
request operation or its linked release.
- Generated metadata, package, or installation impact: none.
Expected effects:
- [x] Analysis facts only; no target interaction.
## Validation performed
- 15 cases in `javascriptSemanticAnalysis.http_method_token.test.ts`; reverting the reader fails 5.
- `src/domain/javascript` — 5644 passing.
- `npm run format:check` — exit 0.
- `npm run lint` — 0 errors.
## Before merge
- [x] This PR addresses a concrete problem or an agreed enhancement.
- [x] Material scope and authority questions are resolved, and any required maintainer scope decision covers the final diff.
- [x] The PR has one focused outcome and the title follows `type(scope): outcome`.
- [x] Tests cover changed observable behavior and meaningful failure paths.
- [x] Owning docs, contracts, and generated metadata are updated where needed.
- [x] I checked the final diff for secrets, unrelated cleanup, and unsupported claims.
## Author readiness
Human owner: @XiaoBinGan
- [x] I reviewed the final diff and relevant existing code, understand the change and its edge cases, and take responsibility for the complete PR, including AI-assisted work.
- [x] I checked the evidence above, confirm it supports the current change, and recorded meaningful validation gaps.
- [x] I declare this PR ready for initial maintainer review.
One regex served both headers — `^[a-z][a-z0-9_.\x2d]*$` after lowercasing — so any token counted as a
declared policy. Measured through `safeResponseMetadata`:
| `Cross-Origin-Resource-Policy` | published | Fetch 3.7 |
| --- | --- | --- |
| `same-origin` | `same-origin` | `same-origin` |
| `SAME-ORIGIN` | `same-origin` | none |
| `Same-Site` | `same-site` | none |
| `same-origin-ish` | `same-origin-ish` | none |
| `same_origin` | `same_origin` | none |
| `unsafe-none` | `unsafe-none` | none |
The value ABNF is `%s"same-origin" / %s"same-site" / %s"cross-origin"`, and `%s` is case-sensitive,
so the internal check nulls every other spelling. Case folding made `SAME-ORIGIN` worse than a bad
echo: it turned a value browsers ignore into the enforced spelling, so an observation claimed
embedding isolation the page did not have.
`X-Content-Type-Options` declares exactly one case-insensitive `nosniff`, and "determine nosniff"
tests `values[0]` of the combined header. The strict whole-value match also dropped valid
declarations — `nosniff` sent on two lines, or `nosniff, sniff`, both published nothing. The reader
takes the first list member now.
| `X-Content-Type-Options` | before | after |
| --- | --- | --- |
| `nosniff` | `nosniff` | `nosniff` |
| `NOSNIFF` | `nosniff` | `nosniff` |
| `nosniff\nnosniff` | none | `nosniff` |
| `nosniff, sniff` | none | `nosniff` |
| `sniff, nosniff` | none | none |
| `nosniff-ish` | `nosniff-ish` | none |
Each header has its own grammar now, and `policyToken` is gone.
`src/browser/CdpSafeMetadata.test.ts` — 133 passing, 17 new cases. Reverting either reader fails
them.
`createPefileReadCompatibility` models pefile's section reads so an import hash is published only
when both readers see the same bytes. Its layout gate rejected any section whose
`PointerToRawData` was not 512-aligned — but pefile 2024.8.26's `get_PointerToRawData_adj()` skips
that rounding when `SectionAlignment < 0x1000` and `PointerToRawData == VirtualAddress`, the
`LdrpWx86FormatVirtualImage` layout ntoskrnl-era drivers use.
The gate already modelled the sub-page case two lines above (`SectionAlignment < 0x1000 ?
FileAlignment : SectionAlignment`), then rejected it against an absolute 512 rule — and
`docs/pe-imports.md` scopes the withhold to an incomplete table or a different row sequence, not to
a file offset.
Measured on a minimal image with `SectionAlignment = FileAlignment = 0x80` and `.idata` at RVA 0x300
== file offset 0x300:
| | before | after |
| --- | --- | --- |
| coverage | `complete` | `complete` |
| issues | `[]` | `[]` |
| `imphash.md5` | `null` | `92cef6cc91a85825f3c8a0516517c66f` |
The withheld hash is the only thing that differed: both readers were already reading the same bytes.
The exception is exact rather than approximate — a section with the same sub-page alignment whose
`PointerToRawData` differs from its `VirtualAddress` still withholds, because pefile does round it
there. That case is the second new test.
pefile's current `master` broadened the condition to every sub-page image; this matches the
2024.8.26 revision the module documents, which is the narrower and safer rule.
`tests/fixtures/binaryDiagnostics/peImports.ts` takes an optional `layout`, so the shared builder
produces the geometry instead of a test hand-encoding a second image. Its default is unchanged —
`SectionAlignment`/`FileAlignment` are written only when supplied, so every existing fixture keeps
its exact bytes.
`src/native/pe` — 265 passing. Restoring the absolute 512 rule fails the sub-page case.
When the target exits, the terminal sends SIGHUP to its foreground process group. The capture guide now says that, and that this signal is not REA cleanup.
Co-authored-by: Cursor <cursoragent@cursor.com>
Node Inspector discovery reports a target as `file://` plus the pathname,
with quotes and backslashes replaced by underscores. Whether such a
pathname is identifiable was decided twice: inline in
authorizeRuntimeTargetLocation and again as NODE_DISCOVERY_AMBIGUOUS in
the createNodeDiscoveryTempDirectory fixture. The copies could drift, and
the fixture could not import the product rule without loading
JavaScriptRuntimeScope and its Electron file-scope chain.
Move the rule to src/inspector/nodeDiscoveryPath.ts, a module with no
imports, and use it from both places. Behavior is unchanged. A unit test
covers the Windows branch, which Linux CI cannot reach through the
boundary tests.
Validation: nodeDiscoveryPath and cancellation tests 12/12;
javascriptRuntimeTargetLocations and javascriptRuntimeObservation 42/42
with TMPDIR containing an underscore (exercises the /tmp fallback);
check:fast passes.
Refs morluto/rea#9996
* fix(apple): rethrow internal invariant violations while resolving a bundle's program file
Bundle target resolution decodes Info.plist with the shared binary plist decoder, which reports a broken internal assumption as InternalInvariantError. The resolver caught every decode failure and reported it as a BinaryTargetError ("Info.plist is malformed, unsupported, or lacks CFBundleExecutable"), and its two outer catches wrapped anything else the same way. A REA defect therefore reached the caller as a fact about the user's bundle.
#11029 made the other plist consumers rethrow the invariant. The resolver's decode site and both outer catches now do the same.
Tests: a boundary test opens a .app and a .bundle through parseBinaryTarget with the decoder replaced by one that reports an invariant violation. Before this change both resolved { ok: false } with a BinaryTargetError; now both reject with the InternalInvariantError. The same bundles open normally with the real decoder.
* test(apple): mock the binary plist decoder at its domain path
Main moved the binary plist materializer from src/artifacts/apple to
src/domain/apple, and AppBundleExecutable now imports it from there. The
invariant test still mocked the old path, which no longer exists, so tsc
failed and the mock would have intercepted nothing.
The test now mocks src/domain/apple/binaryPlistMaterializer.js. With the
rethrow removed from AppBundleExecutable both cases fail; with it they pass.
Review follow-up: firstRuntimeArgument has separate paths for an array hole, a nested array spread and an empty spread followed by another argument. child.kill(...[, "SIGINT"]) sends SIGTERM, child.kill(...[...["SIGINT"]]) sends SIGINT and child.kill(...[], "SIGKILL") sends SIGKILL; the case now pins all three.
Address review feedback on the kill() signal fact:
- Drop the semanticResolutionBlocked import, which isUnshadowedGlobal
superseded.
- Expand spreads of array literals before selecting the signal, so
kill(...[]) reports Node's SIGTERM default and kill(...["SIGINT"])
reports SIGINT. A spread of anything else stays unknown.
- Follow const aliases whose only write is one unconditional initializer
(the same !mutable + semanticStableInitializer rule other producers
use), so `const signal = undefined; kill(signal)` reports SIGTERM.
let, var, reassigned, and shadowed bindings stay unknown.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
inspect_native_instruction reports `not-in-listing` when an address lies
in Ghidra's memory but the listing has no instruction or defined data
there. No decode is attempted, so the answer does not show the bytes are
data, yet the result named no way forward. #10623 added the declared-seed
recovery for procedure_not_found and not_in_procedure; this is the
instruction-level sibling, where a `code` seed applies.
A not-in-listing answer now carries ghidraNotInListingLimitation(source).
It names a `code` seed (or a `function` seed for an entry point) in
REA_GHIDRA_SEED_FILE, says which setting to unset first for a selected
project or checkpoint, and does not assert that the address holds code.
decoded, data and other statuses are unchanged. The installation guide's
seed section lists the new carrier.
Validation: src/ghidra/GhidraProvider.behavior.test.ts fails 1/298 with
the caveat removed and passes 298/298 with it; check:fast passes. No
real Ghidra run.
Refs morluto/rea#3767
A search_bytes cursor resumes the same target, profile and query, and
the limitation said only that. In a real session, renaming a function
between pages changed the procedure name on the next page from the same
cursor, while the page Evidence kept the same target and profile digest
and no limitation explained the difference.
The search_bytes limitation now states that the cursor does not pin
match metadata: procedure names and other match metadata are read live
on each page, so a rename in the session between pages appears on later
pages. This takes the issue's "identify that match metadata is live"
option; binding or qualifying pages to a metadata version is left open.
No prose-asserting test was added, following the direction in #10508.
Validation: src/ghidra/GhidraProvider.behavior.test.ts 296/296;
check:fast passes.
Refs morluto/rea#8365
The npm package does not ship docs/, so a repository-relative guide path
in doctor's remediation could not be opened by npm users. Link the guide
on GitHub instead.
Refs #7018
Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
The Ghidra requirements said official archives may require building the
Linux arm64 decompiler but gave no steps, so doctor's new pointer to that
section led nowhere. Ghidra's own guide lists Linux ARM64 among the
platforms that need user-built natives; link its Building Native
Components section and state it plainly in the remediation too.
Refs #7018
Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>