Skip to content

Building 70 Projects ranging from beginner to advanced so anyone can β€” learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company πŸ‘‡

fix(lisdex): B93 - the null-deref rule's consistent half, folded over the group

CarterPerez-deve214196b22af
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/src/advisory.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/src/advisory.rs
index bf9a8804..9cbb2d94 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/src/advisory.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/src/advisory.rs
@@ -2,8 +2,9 @@
// advisory.rs
use lisdex_core::campaign::TreeProvenance;
-use lisdex_core::crash::Crash;
+use lisdex_core::dedup::CrashGroup;
use lisdex_core::report::SanitizerReport;
+use lisdex_triage::boundary::{FaultAddress, group_is_security_relevant};
use lisdex_triage::classify::classify;
use lisdex_triage::severity::Severity;
@@ -82,26 +83,32 @@ pub struct Advisory {
impl Advisory {
#[must_use]
- pub fn draft(
- target: &str,
- representative: &Crash,
- crash_count: usize,
- tree: TreeProvenance,
- ) -> Option<Advisory> {
+ pub fn draft(target: &str, group: &CrashGroup<'_>, tree: TreeProvenance) -> Option<Advisory> {
+ let representative = group.representative()?;
let text = representative.sanitizer_report();
let parsed = SanitizerReport::parse(text)?;
let classification = classify(text)?;
let key = representative.stack_hash()?.to_owned();
+ let faults: Vec<FaultAddress> = group
+ .crashes()
+ .iter()
+ .map(|crash| {
+ SanitizerReport::parse(crash.sanitizer_report())
+ .map_or(FaultAddress::Absent, |report| {
+ FaultAddress::of(report.fault_address())
+ })
+ })
+ .collect();
Some(Advisory {
target: target.to_owned(),
key,
class: classification.class().to_owned(),
severity: classification.severity(),
weakness: weakness_for(classification.class()),
- security_relevant: classification.is_security_relevant(),
+ security_relevant: group_is_security_relevant(classification.fault_address(), &faults),
crash_site: parsed.crash_site().map(str::to_owned),
frames: parsed.frames().to_vec(),
- crash_count,
+ crash_count: group.len(),
reproducer_bytes: representative.input().len(),
provenance: resolve_provenance(tree, &parsed),
tree,
@@ -208,6 +215,8 @@ pub fn resolve_provenance(tree: TreeProvenance, report: &SanitizerReport) -> Pro
#[cfg(test)]
mod tests {
use lisdex_core::campaign::CampaignId;
+ use lisdex_core::crash::Crash;
+ use lisdex_core::dedup;
use super::*;
@@ -254,10 +263,27 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
Crash::from_report(CAMPAIGN, b"reproducer-bytes".to_vec(), report)
}
+ fn draft(report: &str, count: usize, tree: TreeProvenance) -> Option<Advisory> {
+ let crashes: Vec<Crash> = (0..count).map(|_| crash(report)).collect();
+ let grouping = dedup::group_crashes(&crashes);
+ Advisory::draft("libpng", grouping.groups().first()?, tree)
+ }
+
+ fn near_null_segv(address: &str) -> String {
+ format!(
+ "=================================================================
+==11==ERROR: AddressSanitizer: SEGV on unknown address {address} (pc 0x55a bp 0x1 sp 0x2 T0)
+==11==The signal is caused by a READ memory access.
+ #0 0x55a in png_read_filter_row /src/libpng/pngrutil.c:4180:9
+ #1 0x55b in png_read_row /src/libpng/pngread.c:512:7
+SUMMARY: AddressSanitizer: SEGV (/out/harness+0x55a) in png_read_filter_row
+"
+ )
+ }
+
#[test]
fn a_draft_carries_the_measured_facts_of_its_group() {
- let advisory =
- Advisory::draft("libpng", &crash(REAL_HEAP_WRITE), 44, TreeProvenance::Field).unwrap();
+ let advisory = draft(REAL_HEAP_WRITE, 44, TreeProvenance::Field).unwrap();
assert_eq!(advisory.target(), "libpng");
assert_eq!(advisory.class(), "heap-buffer-overflow(write)");
assert_eq!(advisory.severity(), Severity::Exploitable);
@@ -276,16 +302,17 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
"==12==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x1 at pc 0x2\n #0 0x3 (/out/lib.so+0x4)\n",
);
assert_eq!(unkeyed.stack_hash(), None);
+ let crashes = vec![unkeyed];
+ let grouping = dedup::group_crashes(&crashes);
assert!(
- Advisory::draft("libpng", &unkeyed, 1, TreeProvenance::Field).is_none(),
- "an advisory names one bug, and a crash the triage layer refused to key is not known to be one bug"
+ grouping.groups().is_empty() && grouping.unkeyed_crashes() == 1,
+ "an advisory names one bug, and a crash the triage layer refused to key never forms a group to name"
);
}
#[test]
fn a_planted_benchmark_crash_is_never_disclosable() {
- let advisory =
- Advisory::draft("libpng", &crash(CANARY_CRASH), 44, TreeProvenance::Field).unwrap();
+ let advisory = draft(CANARY_CRASH, 44, TreeProvenance::Field).unwrap();
assert_eq!(advisory.provenance(), Provenance::SyntheticBenchmark);
assert!(
!advisory.is_disclosable(),
@@ -318,8 +345,7 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
#[test]
fn a_real_crash_is_not_mistaken_for_a_benchmark() {
- let advisory =
- Advisory::draft("libpng", &crash(REAL_HEAP_WRITE), 1, TreeProvenance::Field).unwrap();
+ let advisory = draft(REAL_HEAP_WRITE, 1, TreeProvenance::Field).unwrap();
assert_eq!(
advisory.provenance(),
Provenance::Field,
@@ -349,13 +375,7 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
"the fixture must isolate the signal: the frame guard sees nothing benchmark-shaped here"
);
- let advisory = Advisory::draft(
- "libpng",
- &crash(REAL_HEAP_WRITE),
- 44,
- TreeProvenance::Benchmark,
- )
- .unwrap();
+ let advisory = draft(REAL_HEAP_WRITE, 44, TreeProvenance::Benchmark).unwrap();
assert_eq!(advisory.provenance(), Provenance::SyntheticBenchmark);
assert!(
!advisory.is_disclosable(),
@@ -365,17 +385,10 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
#[test]
fn an_unknown_tree_decides_on_frame_evidence_in_both_directions() {
- let planted =
- Advisory::draft("libpng", &crash(CANARY_CRASH), 1, TreeProvenance::Unknown).unwrap();
+ let planted = draft(CANARY_CRASH, 1, TreeProvenance::Unknown).unwrap();
assert_eq!(planted.provenance(), Provenance::SyntheticBenchmark);
- let field = Advisory::draft(
- "libpng",
- &crash(REAL_HEAP_WRITE),
- 1,
- TreeProvenance::Unknown,
- )
- .unwrap();
+ let field = draft(REAL_HEAP_WRITE, 1, TreeProvenance::Unknown).unwrap();
assert_eq!(
field.provenance(),
Provenance::Field,
@@ -407,14 +420,44 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
#[test]
fn an_advisory_remembers_which_tree_it_came_from() {
- let advisory = Advisory::draft(
- "libpng",
- &crash(REAL_HEAP_WRITE),
+ let advisory = draft(REAL_HEAP_WRITE, 1, TreeProvenance::Benchmark).unwrap();
+ assert_eq!(advisory.tree(), TreeProvenance::Benchmark);
+ }
+
+ #[test]
+ fn a_null_deref_group_whose_offset_moves_is_filed_as_security() {
+ let fixed = near_null_segv("0x0000000000000010");
+ let moved = near_null_segv("0x0000000000004000");
+
+ let varying = vec![crash(&fixed), crash(&moved)];
+ let grouping = dedup::group_crashes(&varying);
+ assert_eq!(
+ grouping.groups().len(),
1,
- TreeProvenance::Benchmark,
+ "the two captures must land in ONE group or this tests nothing about group consistency"
+ );
+ assert_eq!(grouping.groups()[0].len(), 2);
+
+ let advisory =
+ Advisory::draft("libpng", &grouping.groups()[0], TreeProvenance::Field).unwrap();
+ assert!(
+ advisory.is_security_relevant(),
+ "Chromium files a null dereference as non-security only when the offset is CONSISTENT; an offset that moves from 0x10 to 0x4000 with the input is attacker-influenced, and judging the representative crash alone files it as non-security"
+ );
+ }
+
+ #[test]
+ fn a_null_deref_group_at_one_fixed_offset_stays_non_security() {
+ let advisory = draft(
+ &near_null_segv("0x0000000000000010"),
+ 2,
+ TreeProvenance::Field,
)
.unwrap();
- assert_eq!(advisory.tree(), TreeProvenance::Benchmark);
+ assert!(
+ !advisory.is_security_relevant(),
+ "the consistency rule must not promote every null dereference, or the non-security verdict stops meaning anything"
+ );
}
#[test]
@@ -430,10 +473,12 @@ SUMMARY: AddressSanitizer: heap-buffer-overflow (/out/harness+0x4a1) in MAGMA_pn
#[test]
fn an_undefined_severity_is_reported_as_unassessed() {
- let ubsan = crash(
+ let advisory = draft(
"pngrutil.c:1204:7: runtime error: left shift of negative value -1\n #0 0x55a in png_do_read_transform pngrtran.c:1204:7\n",
- );
- let advisory = Advisory::draft("libpng", &ubsan, 1, TreeProvenance::Field).unwrap();
+ 1,
+ TreeProvenance::Field,
+ )
+ .unwrap();
assert_eq!(advisory.severity(), Severity::Undefined);
assert!(
!advisory.severity_is_assessed(),
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/bundling.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/bundling.rs
index 974e214f..8ecfc9e2 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/bundling.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/bundling.rs
@@ -3,6 +3,7 @@
use lisdex_core::campaign::{CampaignId, TreeProvenance};
use lisdex_core::crash::Crash;
+use lisdex_core::dedup;
use lisdex_report::advisory::Advisory;
use lisdex_report::bundle::{
self, ADVISORY_JSON, ADVISORY_MARKDOWN, REPRODUCE_SCRIPT, REPRODUCER, Reproducer,
@@ -32,8 +33,12 @@ SUMMARY: AddressSanitizer: SEGV (/lib/x86_64-linux-gnu/libc.so.6+0x4553b) in kil
";
fn advisory(report: &str) -> Advisory {
- let crash = Crash::from_report(CAMPAIGN, POC.to_vec(), report);
- Advisory::draft("libpng", &crash, 12, TreeProvenance::Field).expect("fixture must draft")
+ let crashes: Vec<Crash> = (0..12)
+ .map(|_| Crash::from_report(CAMPAIGN, POC.to_vec(), report))
+ .collect();
+ let grouping = dedup::group_crashes(&crashes);
+ Advisory::draft("libpng", &grouping.groups()[0], TreeProvenance::Field)
+ .expect("fixture must draft")
}
fn scratch(name: &str) -> std::path::PathBuf {
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/rendering.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/rendering.rs
index bade7819..2e41cf03 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/rendering.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-report/tests/rendering.rs
@@ -3,6 +3,7 @@
use lisdex_core::campaign::{CampaignId, TreeProvenance};
use lisdex_core::crash::Crash;
+use lisdex_core::dedup;
use lisdex_report::advisory::{Advisory, OPERATOR_INPUTS};
use lisdex_report::json::{self, GHSA_ECOSYSTEM_FOR_C_LIBRARIES};
use lisdex_report::markdown;
@@ -34,8 +35,15 @@ pngrutil.c:1204:7: runtime error: left shift of negative value -1
";
fn advisory(report: &str) -> Advisory {
- let crash = Crash::from_report(CAMPAIGN, b"reproducer-bytes".to_vec(), report);
- Advisory::draft("libpng", &crash, 44, TreeProvenance::Field).expect("fixture must draft")
+ drafted(report, TreeProvenance::Field)
+}
+
+fn drafted(report: &str, tree: TreeProvenance) -> Advisory {
+ let crashes: Vec<Crash> = (0..44)
+ .map(|_| Crash::from_report(CAMPAIGN, b"reproducer-bytes".to_vec(), report))
+ .collect();
+ let grouping = dedup::group_crashes(&crashes);
+ Advisory::draft("libpng", &grouping.groups()[0], tree).expect("fixture must draft")
}
#[test]
@@ -78,9 +86,7 @@ fn a_planted_benchmark_finding_is_rendered_with_a_refusal_and_no_filing_instruct
#[test]
fn a_tree_refusal_does_not_claim_a_call_stack_it_cannot_show() {
- let crash = Crash::from_report(CAMPAIGN, b"reproducer-bytes".to_vec(), REAL_HEAP_WRITE);
- let from_tree = Advisory::draft("libpng", &crash, 44, TreeProvenance::Benchmark)
- .expect("fixture must draft");
+ let from_tree = drafted(REAL_HEAP_WRITE, TreeProvenance::Benchmark);
let rendered = markdown::render(&from_tree, None);
assert!(rendered.contains("DO NOT FILE THIS ADVISORY"));
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/boundary.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/boundary.rs
index 3bb87ede..13a6088e 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/boundary.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/boundary.rs
@@ -40,6 +40,23 @@ impl FaultAddress {
}
}
+#[must_use]
+pub fn group_is_security_relevant(representative: FaultAddress, group: &[FaultAddress]) -> bool {
+ let Some(FaultAddress::NearNull(first)) = group.first() else {
+ return representative.is_security_relevant();
+ };
+ let mut varies = false;
+ for fault in group {
+ let FaultAddress::NearNull(value) = fault else {
+ return representative.is_security_relevant();
+ };
+ if value != first {
+ varies = true;
+ }
+ }
+ varies
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -82,6 +99,61 @@ mod tests {
assert!(!FaultAddress::of(Some(NULL_DEREFERENCE_BOUNDARY - 1)).is_security_relevant());
}
+ #[test]
+ fn a_group_faulting_at_one_fixed_small_offset_stays_non_security() {
+ let group = [FaultAddress::NearNull(0x10), FaultAddress::NearNull(0x10)];
+ assert!(
+ !group_is_security_relevant(FaultAddress::NearNull(0x10), &group),
+ "a struct field read off a null pointer lands at the same offset every time, and Chromium calls that non-security"
+ );
+ }
+
+ #[test]
+ fn a_group_whose_small_offsets_disagree_is_security_relevant() {
+ let group = [FaultAddress::NearNull(0x10), FaultAddress::NearNull(0x4000)];
+ assert!(
+ group_is_security_relevant(FaultAddress::NearNull(0x10), &group),
+ "Chromium's rule is non-security only for a CONSISTENT small offset; an offset that moves with the input is attacker-influenced even though every address is small, and judging the representative alone files it as non-security"
+ );
+ }
+
+ #[test]
+ fn one_wild_address_in_the_group_falls_back_to_the_per_report_verdict() {
+ let group = [
+ FaultAddress::NearNull(0x10),
+ FaultAddress::Wild(BAND_ADDRESS),
+ ];
+ assert!(
+ group_is_security_relevant(FaultAddress::Wild(BAND_ADDRESS), &group),
+ "the consistency rule only governs groups that are entirely near-null; anything else keeps the verdict it already had"
+ );
+ assert!(
+ !group_is_security_relevant(FaultAddress::NearNull(0x10), &group),
+ "and it defers to the representative rather than inventing a verdict of its own"
+ );
+ }
+
+ #[test]
+ fn an_empty_group_defers_rather_than_inventing_a_verdict() {
+ assert!(!group_is_security_relevant(
+ FaultAddress::NearNull(0x10),
+ &[]
+ ));
+ assert!(group_is_security_relevant(
+ FaultAddress::Wild(BAND_ADDRESS),
+ &[]
+ ));
+ }
+
+ #[test]
+ fn a_single_crash_group_cannot_be_shown_to_vary() {
+ let group = [FaultAddress::NearNull(0x10)];
+ assert!(
+ !group_is_security_relevant(FaultAddress::NearNull(0x10), &group),
+ "one observation is not evidence of a moving offset, and claiming otherwise would file every null dereference as security"
+ );
+ }
+
#[test]
fn a_report_with_no_fault_address_answers_nothing_rather_than_safe() {
assert_eq!(FaultAddress::of(None), FaultAddress::Absent);
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex/src/main.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex/src/main.rs
index a83be9f9..a2556544 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex/src/main.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex/src/main.rs
@@ -1807,7 +1807,7 @@ fn advisories(args: &AdvisoryArgs) -> Result<(), Box<dyn Error>> {
};
let stem = short_hash(crash.stack_hash());
let package = args.package.as_deref().unwrap_or_else(|| campaign.target());
- match Advisory::draft(package, crash, group.len(), campaign.tree()) {
+ match Advisory::draft(package, group, campaign.tree()) {
Some(advisory) => drafted.push((stem, advisory)),
None => eprintln!(
"warning: bug {stem} has no dedup key, so its crashes are not known to be one bug and no advisory names them"
@@ -1869,7 +1869,7 @@ fn bundles(args: &BundleArgs) -> Result<(), Box<dyn Error>> {
};
let stem = short_hash(crash.stack_hash());
let package = args.package.as_deref().unwrap_or_else(|| campaign.target());
- let Some(advisory) = Advisory::draft(package, crash, group.len(), campaign.tree()) else {
+ let Some(advisory) = Advisory::draft(package, group, campaign.tree()) else {
eprintln!(
"warning: bug {stem} has no dedup key, so no advisory names it and no bundle is written"
);
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/02-ARCHITECTURE.md b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/02-ARCHITECTURE.md
index c4751611..52dd9380 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/02-ARCHITECTURE.md
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/02-ARCHITECTURE.md
@@ -142,9 +142,12 @@ differential oracle, and it is stronger than any amount of reading the code.
7. **`classify::classify` judges severity** from the report text: CASR for the
main verdict, `FaultAddress` for the null-versus-wild distinction.
-8. **`Advisory::draft` builds the disclosure** from the group's representative
- crash and the campaign's tree provenance, refusing the fields it cannot know
- and refusing disclosure entirely for anything from a benchmark tree.
+8. **`Advisory::draft` builds the disclosure** from the whole bug group and the
+ campaign's tree provenance, refusing the fields it cannot know and refusing
+ disclosure entirely for anything from a benchmark tree. It takes the group
+ rather than one crash because two of its judgements are group-level: how many
+ crashes the bug has, and whether a near-null fault offset holds still across
+ them.
## Design Decisions
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.md b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.md
index f2ef0eee..aafd0ae4 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.md
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.md
@@ -310,21 +310,34 @@ override is visible rather than hidden.
`is_security_relevant` is what makes a null dereference render as
"(non-security)" in the panels.
+That verdict is not decided per report. Chromium's rule is "consistent, small,
+fixed offset", and consistency is a property of a bug group rather than of one
+crash: the same bug landing at `0x10` on one input and `0x4000` on another has an
+offset that moves with the input, which makes it attacker-influenced even though
+both addresses are small. `group_is_security_relevant` folds every fault address
+in the group and only keeps the non-security verdict when they agree. A crash
+whose report will not parse contributes `Absent`, which disqualifies the whole
+group from the rule - deferring is the safe direction, and concluding "all
+near-null" from the subset that happened to parse is not.
+
## Stage 7: The Advisory
-`Advisory::draft` builds from a group's representative crash:
+`Advisory::draft` takes the whole bug group, because an advisory describes a bug
+rather than a single crash, and the group-level checks above need every crash in
+it:
```rust
pub fn draft(
target: &str,
- representative: &Crash,
- crash_count: usize,
+ group: &CrashGroup<'_>,
tree: TreeProvenance,
) -> Option<Advisory>
```
-It returns `None` when the crash cannot support an advisory, which is the same
-refusal discipline as everywhere else.
+It returns `None` when the group cannot support an advisory, which is the same
+refusal discipline as everywhere else. Note there is no `crash_count` parameter:
+it was always `group.len()` at every call site, and a count passed separately
+from the thing it counts is a parameter that can disagree with reality.
`tree` is required rather than optional on purpose. Disclosability depends on
what kind of tree the campaign ran against, so making it a parameter means the
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.md b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.md
index a3c4c63b..9ce4f9d4 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.md
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.md
@@ -52,18 +52,31 @@ whose coverage curve climbs for at least an hour.
### 5. Make the null-dereference rule match Chromium's
-Chromium's rule for whether a null dereference is security relevant has two
-halves. lisdex implements the address-range half: a fault near zero is a null
-dereference, not a wild pointer.
-
-The other half is *consistency*: a null dereference that reproduces identically
-across runs is a plain bug, while one whose fault address moves between runs
-suggests something is being computed from uninitialized memory, which is a
-different and more interesting problem.
-
-Implementing this means running each crash more than once and comparing. Think
-about what that costs on a pile of 200 crashes, and whether the answer changes
-any advisory.
+Chromium's rule for whether a null dereference is security relevant reads
+"consistent, small, fixed offset". lisdex implements two of those three, and the
+gap left is a genuinely different question from the one it already answers.
+
+*Small* is `FaultAddress::of`: a fault below 32 KiB is a null dereference plus a
+struct offset, not a wild pointer. *Fixed* is `group_is_security_relevant`, which
+folds the fault addresses of every crash in a bug group: if the same bug lands at
+`0x10` on one input and `0x4000` on another, the offset moves with the input, so
+it is attacker-influenced and gets filed as security even though every individual
+address is small. Note which way the old gap failed - permissive, filing a moving
+offset as non-security.
+
+What is left is *consistency across runs of the same input*, which is a different
+signal entirely. An address that moves when you re-run one unchanged input is not
+attacker-controlled arithmetic; it suggests something is being computed from
+uninitialized memory. Implementing it means executing each crash more than once
+and comparing, so think about what that costs on a pile of 200 crashes, and
+whether the answer would change any advisory lisdex currently emits.
+
+Fair warning from the shipped version: on both real libpng campaigns the
+group-consistency rule changes **nothing**, because every canary faults at the
+process PID, far beyond the boundary, so no group is entirely near-null. A
+correctness fix with no measured effect on the corpus you have is still worth
+making when the gap fails in the unsafe direction, but you should know going in
+that you will not see a number move.
### 6. Target-level provenance beyond Magma