| """Predicted result class of every scripts/arraylit_cases.py case under |
| each hypothesis, for scripts/check_predictions.py (njs.cve-2022-28049). |
| |
| Prints a TSV with one column per <model>:<variant>. Classes are OK, |
| WRONG, ASAN, INV (an ARRAYLIT-INVARIANT check fired) or - (not modelled). |
| |
| dev: the developer's model, from the message of f65981b0 ("allocation of |
| large array literals may result in null-pointer dereference ... the |
| instruction code assumes that array is always flat ... check fast_array |
| flag before accessing array->start"). Read literally, a large array |
| literal (slow array) dereferences a NULL array->start; the fix removes |
| that for the array instruction. It predicts the crash on every slow |
| literal on the base build and a correct array on every literal after |
| the patch. |
| ours: H1, the CVE crash. NJS_VMCODE_ARRAY with ctor set (a literal with a |
| trailing hole or a leading value before holes: shapes elision and |
| ctorlead) fills every slot through array->start; on a slow array |
| (length + 8 > 32768, i.e. length > 32760) array->start is NULL and the |
| write faults (ASAN). The developer patch guards the fill loop with |
| fast_array, so on a slow array it is skipped: a pure-elision literal is |
| then all holes (OK), and a ctorlead literal has its leading value lost |
| (WRONG, see H2). A fast literal (length <= 32760) builds a flat array |
| and is OK on every build. |
| H2, the residual element loss (independent, not the CVE crash). A |
| literal with an actual element at a defined index initialises it through |
| NJS_VMCODE_PROPERTY_INIT, which writes array->start[index]; on a slow |
| array the value is lost and the index reads undefined, without a crash. |
| This holds on the base build for the non-ctor shapes (element, tailval, |
| mixed) that are slow (WRONG, no crash), and on the developer-patch build |
| for every slow literal with an element (element, tailval, mixed, and |
| ctorlead, whose crash the patch turned into this loss). Upstream fixed |
| it in 3557c57d (a slow-array branch in the element initialiser; its |
| verbatim hunk uses later APIs and does not compile on the base, so the |
| elemfix variant is a backport that uses njs_value_property_i64_set, the |
| indexed setter of the base array builtins, source backport:3557c57d); it is |
| independent of the CVE crash by the separability rule (the developer |
| patch alone repairs the pure-elision crashes, 3557c57d alone repairs the |
| element loss, and the two repaired sets are disjoint), so it is not in a |
| root patch. At upstream master the element loss is fixed. |
| Variants: before (base), after (developer patch), elemfix / |
| after_elemfix (3557c57d alone / with the developer patch), assert_before |
| (base + arraylit_invariant_before.diff, which aborts with |
| ARRAYLIT-INVARIANT before the NULL write when the ctor fill loop meets a |
| slow array), assert_after (developer patch + |
| arraylit_invariant_after.diff, a silent assertion that the fill loop |
| runs only on a fast array; never the violation, same classes as after), |
| upstream_master. |
| |
| The boundary length (32760 fast, 32761 slow) and the element-loss |
| behaviour were observed on the base and developer builds with exploratory |
| scripts before this file was written (not kept as logs); the predictions |
| for the 30 cases were written on 2026-10-13 before the `before` variant |
| run. The expected values are the Node.js v22.22.2 outputs |
| (scripts/arraylit_expected.tsv). |
| """ |
| import csv |
| import sys |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from arraylit_cases import cases |
|
|
| COLS = ["dev:before", "dev:after", "ours:before", "ours:after", "ours:elemfix", |
| "ours:after_elemfix", "ours:assert_before", "ours:assert_after", |
| "ours:upstream_master"] |
|
|
|
|
| def classes(shape, n, slow, he): |
| |
| if shape == "control": |
| return dict.fromkeys(COLS, "OK") |
| if not slow: |
| return dict.fromkeys(COLS, "OK") |
| |
| if shape == "elision": |
| |
| base = "ASAN"; after = "OK"; elemfix = "ASAN"; after_elemfix = "OK" |
| a_before = "INV"; a_after = "OK"; master = "OK" |
| elif shape == "ctorlead": |
| |
| |
| base = "ASAN"; after = "WRONG"; elemfix = "ASAN"; after_elemfix = "OK" |
| a_before = "INV"; a_after = "WRONG"; master = "OK" |
| else: |
| |
| base = "WRONG"; after = "WRONG"; elemfix = "OK"; after_elemfix = "OK" |
| a_before = "WRONG"; a_after = "WRONG"; master = "OK" |
| return {"dev:before": "OK", "dev:after": "OK", |
| "ours:before": base, "ours:after": after, "ours:elemfix": elemfix, |
| "ours:after_elemfix": after_elemfix, "ours:assert_before": a_before, |
| "ours:assert_after": a_after, "ours:upstream_master": master} |
|
|
|
|
| def dev_before(slow): |
| |
| return "ASAN" if slow else "OK" |
|
|
|
|
| def main(): |
| w = csv.writer(sys.stdout, delimiter="\t", lineterminator="\n") |
| w.writerow(["case"] + COLS) |
| for name, shape, n, slow, he, _body in cases(): |
| c = classes(shape, n, slow, he) |
| c["dev:before"] = dev_before(slow and shape != "control") |
| c["dev:after"] = "OK" |
| |
| if name == "poc_shape": |
| c = {"dev:before": "ASAN", "dev:after": "OK", "ours:before": "ASAN", |
| "ours:after": "OK", "ours:elemfix": "ASAN", "ours:after_elemfix": "OK", |
| "ours:assert_before": "INV", "ours:assert_after": "OK", |
| "ours:upstream_master": "OK"} |
| w.writerow([name] + [c[col] for col in COLS]) |
| |
| |
| w.writerow(["poc", "ASAN", "OK", "ASAN", "OK", "ASAN", "OK", "INV", "OK", "OK"]) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
