CoreFoundation reads some XML plists that strict XML rejects, such as
documents with a double hyphen in a comment or a control character in a
string. inspect_plist refused them although plutil -lint accepts them,
and the outcome depended on how file(1) described the bytes.
When REA's XML reader refuses a document's syntax, inspection now takes
the existing plutil conversion route. The result keeps format xml and a
limitation names REA's reason. A document plutil also rejects stays
refused with its diagnostic, and plist structure errors in well-formed
XML are still refused without conversion.
Fixes#12234
Admit exact string heap aliases and retain independent Module row facts for distinct declarations. Bind the optional partial row to the same scope checks as named Module Evidence.
* fix(managed): preserve duplicate GUID stream ambiguity
* fix(managed): preserve ambiguous metadata stream declarations (#12226)
Use one stream declaration owner for heap and table diagnostics. Keep user strings and row-layout uncertainty separate from independent PE/CLI observations.
* test(managed): separate heap entries from cache behavior
* fix(managed): preserve duplicate blob heap ambiguity (#12258)
Resolve #Blob in the shared stream layout. Preserve nil references and independent facts without emitting unsupported keys, signatures or hashes.
* fix(erlang): disclose BEAM bytes trailing the declared FOR1 form
A conformant FOR1 container sizes its form to the whole file, so bytes
past the form end are an unexamined appended or corrupt region. The
inspector decoded chunks only within the form but still reported
coverage.status "complete" with no mention of the surplus, so a caller
could not distinguish a clean BEAM from one carrying foreign trailing
bytes.
Compute the trailing byte count, report coverage.status "partial" with a
trailing_bytes field, and append a limitation naming the form end and the
unexamined count. Clean containers stay "complete" with trailing_bytes 0.
* fix(erlang): reparse retained BEAM Evidence without the trailing-bytes field
Evidence retained by a build predating coverage.trailing_bytes has no such
property, and projectErlangBeamView reparses that record with the strict
erlangBeamSchema. A required field rejected those records with an input error
before any summary or page could render, breaking the offline retained-Evidence
flow even for clean files.
Default coverage.trailing_bytes to 0 so historical records reparse while every
new parse still emits the concrete count and preserves each record's stored
status.
* fix(erlang): keep retained BEAM trailing coverage unknown, not zero
Defaulting coverage.trailing_bytes to 0 manufactured a "no trailer" reading for
Evidence retained before the field existed, even when its retained bounds
(artifact.bytes versus form.location.bytes) prove a trailer. Make the field
optional so a pre-field record reparses as unknown instead of a fabricated
zero, while every new parse still emits the concrete count.
* fix(erlang): admit chunk extents before applying count limits
* docs(erlang): explain trailing BEAM coverage
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* feat(elf): decode FDO packaging and dlopen note metadata
Name FDO notes within their owner's namespace: type 0xcafe1a7e is
fdo_packaging_metadata and 0x407c0c0a is fdo_dlopen_metadata. One
elfNoteTypeName(owner, type) replaces the GNU-only gnuNoteTypeName.
Each entry gains an fdo field next to gnu. metadata holds the descriptor's
JSON object (packaging) or array (dlopen) when it is NUL-terminated UTF-8
JSON followed only by NUL padding; otherwise metadata is null and issue
names the broken rule, without failing the inspection. Each descriptor
range is decoded once and its retained JSON text is charged to the shared
note text budget per repeated entry. A limitation marks the metadata as a
producer declaration.
Fixes#7235
* fix(elf): key FDO note decoding by note type
The FDO decode cache was keyed by descriptor range only, but the note
type selects the required JSON shape. Overlapping PT_NOTE and SHT_NOTE
tables can give one descriptor range a packaging note and a dlopen note,
and the second reused the first note's verdict. Include the type name in
the key.
Refs #7235
* fix(elf): bound FDO note decoding before parsing JSON
The FDO decoder charged only descriptor source bytes before JSON.parse,
but a dense JSON value such as [{},{},...] decodes to about 50 times its
source size in heap before the service and Evidence copy it again. A
16 MiB descriptor took about 790 MiB of heap; one near the default
64 MiB file budget could exhaust the Node heap. Leave descriptors above
64 KiB undecoded with an issue naming the limit; real FDO notes are a
few hundred bytes.
Refs #7235
* fix(elf): share one FDO decode allowance across the report
The 64 KiB FDO decode bound applied to each descriptor, so raising
max_entries to 256 admitted 256 distinct dense 64 KiB notes: a 16 MiB
file added about 700 MiB of heap before Evidence copied it again.
Charge each distinct descriptor's size to one 64 KiB allowance per
report; a range repeated by another table reuses its decode, and notes
past the allowance keep their entry with an issue.
Refs #7235
* test(desktop): exercise the shared JSON depth guard in the heap suite
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* test(javascript): cover the isolated-world probe outside Electron identity
* fix(javascript): expand Electron call paths only with an Electron reference
* test(javascript): cover Electron reach through resolved names, aliases and worker URLs
* fix(javascript): attribute call-path unknowns only where the walk can reach Electron
* test(javascript): cover a hoisted read that precedes a loader alias
* fix(javascript): keep call-path unknowns for late-initialized loader aliases
* test(javascript): drop a duplicate loader-alias case
* test(javascript): cover loader aliases reached through bindings and calls
* fix(javascript): prove a late initializer loader-free before dropping its unknown
* test(javascript): cover loaders behind default parameters, wrappers and long alias chains
* fix(javascript): resolve identifiers inside late initializers and bound the loader proof
* fix(javascript): bound late loader proofs and preserve input uncertainty
* fix(javascript): fail closed for receiver and mutated loaders
* fix(javascript): close loader-free proof gaps
* fix(javascript): retain uncertain loader sources
* test(javascript): cover remaining loader proof gaps
* fix(javascript): bound alias writes and preserve loader uncertainty
* test(javascript): cover demand-driven loader mutation facts
* perf(javascript): index loader mutation facts on demand
* style(javascript): apply oxfmt to the loader proof changes
* test(javascript): cover inherited loaders and rebound alias writes
* fix(javascript): preserve inherited loaders and rebound aliases
* test(evaluation): update scoped feature coverage oracle
* test(javascript): cover inherited loader proof gaps
* fix(javascript): preserve projected and inherited loaders
* fix(javascript): prove safe parameter member reads
* test(javascript): cover loader proof review gaps
* fix(javascript): close remaining loader proof gaps
* fix(javascript): preserve qualified global replacements
* fix(javascript): preserve spread rest uncertainty
* fix(javascript): retain retried handler uncertainty
* fix(javascript): retain import.meta loader uncertainty
* fix(javascript): detach fresh constructed aliases
* fix(javascript): check inherited members of ambient loaders
* test(javascript): parse call-path gate fixtures as established CommonJS
* fix(javascript): prove projected locals inside late initializers
A function-local binding was accepted by scope alone, so a destructuring
projection such as `const { r } = {}` inside a late initializer never met
the inherited-member check that a top-level projection goes through. Route
projected locals through the binding proof; locals with inline initializers
keep the scope shortcut, since the walk already visits their expressions.
* fix(javascript): keep late results with changed prototypes or import.meta uncertain
The loader-free proof inspected member expressions inside a late function
but not what its caller does with the result. With `Object.prototype.load =
require`, `var load = () => ({})` and `load().load("electron")` reach the
loader through a member selected after the call, and a bare `import.meta`
returned after `import.meta.load = ...` does the same. Check each result
expression: a literal fails when its prototype chain gained members, a bare
`import.meta` when any of its members changed, and a result of unknown shape
when either happened. Promise and generator results inherit from
Object.prototype as well. `SemanticPropertyPathCoverage.touches` answers
whether any retained write or escape sits below a prefix.
* fix(javascript): detach replacements held by fresh bindings
`alias = replacement` with `const replacement = {}` selected an identifier
initializer, so the later `alias.other = 1` stayed a shared write on the
original alias group and the resolver treated `base` as overwritten,
dropping its bridge call path. Resolve the identifier to its binding and
accept it when that binding only ever received one fresh allocation.
Bindings that can hold the original object keep the shared write.
* fix(javascript): charge loader proofs through the wrapper-visit budget
#11319 replaced the wrapper-visit counter with a Budget, so the loader proof charge no longer compiled on current main. Spend it through the shared helper, which records the same limit.
* test(javascript): keep the alias bound off the quadratic write index
The 8,000 by 8,000 alias bound spent its time in the ambient write index, which walks every store to an object for each member write. That cost is the same on main and is not what the bound covers. Reach the same 64 million alias and write pairs with 32,000 aliases and 2,000 writes, which runs in about 2.5 seconds instead of 8.5 on the same host.
Drop the 30 second overrides on both alias bounds too. They halved the hosted CI deadline the source project gives them, and the testing guide asks tests to leave deadlines to the project.
* refactor(javascript): ask the effect log for loader proof effects
Main now guards reads of the effect indexes outside javascriptSemanticEffectLog.ts. The loader proof read them directly in 15 places. Route those reads through the log: the existing ambientPathMayHaveChanged and bindingHasMemberWrites queries, plus three timeless queries for a path or any member below it, an ambient binding write, and an escape at a site other than the call being proved. The answers are unchanged.
* fix(javascript): retain uncertainty for changed ambient values
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* test(gpu): protect CUDA 0x2000 LZ4 payload identity
CUDA LZ4 entries were decodable through the shared block decoder, but no
public workflow selected a 0x2000 entry and checked the retained PTX bytes.
The fixture builder offered only none/zstd/legacy, so the profile dispatch in
readCudaFatbinary had no decoded-payload control.
Add an lz4 fixture profile backed by a single literal sequence, extend the
existing boundary matrix to it, and add boundary plus CLI/MCP regressions that
assert compression_id, decoded size, retained PTX text and the decoded digest.
A malformed decoded-length control covers the rejection path. Temporarily
disabling the 0x2000 profile selection makes all three new cases fail.
Verified with npm run check:fast and the GPU boundary, acceptance, inventory
and LZ4 suites (161 passed). No native liblz4 or CUDA compiler is required.
* style(gpu): apply repository formatting
* test(gpu): follow the shared CLI session rename in the code-object test
Upstream #10412 removed runFileCli from the CLI fixture and moved every
acceptance test onto the file-level shared process (cli.run). Rebasing
onto current main left this new LZ4 assertion calling the deleted helper,
so the whole file failed with a ReferenceError and the shared worker was
torn down for the rest of the suite.
* fix(process): decode analyzer worker control frames as strict UTF-8
Refs #12145.
* fix(process): decode bounded control input without byte replacement
* fix(android): bound guardian readiness by the first UTF-8 frame (#12176)
Follows the readiness framing and lifecycle findings reported by @LcokHcak in #3048.
* refactor(process): share Linux resource limit admission with EVM
Refs #12128
* fix(desktop): bind process details to their Linux generation
Refs #12134.
* fix(desktop): bind open-file samples to their process generation
Refs #12134.
* fix(desktop): reject split ZIP volume metadata
Refs #12137
* refactor(zip): read Zip64 disk fields through BinaryReader
* fix(desktop): validate ZIP extra fields before selection
Refs #12146
* fix(desktop): keep bounded ZIP pairing compatible with Python 3.9
* fix(desktop): retain exact counts in bounded Zip64 views
* fix(desktop): follow the declared Zip64 directory frame
* fix(desktop): recognize empty ZIP state views (#12163)
* fix(desktop): recognize empty ZIP state views
(cherry picked from commit 263b25bd34)
* fix(desktop): reuse empty ZIP admission for wrapped documents
* refactor(zip): share the local-header signature with desktop state
---------
Co-authored-by: wunianze666-netizen <wunianze666@gmail.com>
* test(zip): inherit the portable ZIP count deadline
---------
Co-authored-by: wunianze666-netizen <wunianze666@gmail.com>