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 π
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
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.rsindex 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.rsuse 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_pnCrash::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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.mdindex 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 themain 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 Decisionsdiff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.md b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/03-IMPLEMENTATION.mdindex 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:```rustpub 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 onwhat kind of tree the campaign ran against, so making it a parameter means thediff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.md b/PROJECTS/advanced/zero-day-vulnerability-scanner/learn/04-CHALLENGES.mdindex 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