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 đŸ‘‡

feat(lisdex): M7.6 - at 36 KiB both cited systems say security and the library lisdex followed says no

CarterPerez-dev7f3aba870e7b
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-core/src/report.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-core/src/report.rs
index 1a2e4c58..c9eee3bd 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-core/src/report.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-core/src/report.rs
@@ -22,6 +22,8 @@ const MODULE_OFFSET_MARKER: &str = "+0x";
const UNSYMBOLIZED_SYMBOL: &str = "<unknown>";
const REDACTED_ADDRESS: &str = "0xADDR";
const HEX_PREFIX: char = 'x';
+const HEX_LITERAL_PREFIX: &str = "0x";
+const HEX_RADIX: u32 = 16;
const MODULE_TAG_SEPARATOR: char = '@';
const PATH_SEPARATOR: char = '/';
const LOCATION_SEPARATOR: char = ':';
@@ -50,6 +52,7 @@ const NOISE_FRAME_EXACT: [&str; 7] = [
pub struct SanitizerReport {
sanitizer: String,
kind: String,
+ fault_address: Option<u64>,
frames: Vec<String>,
}
@@ -61,6 +64,7 @@ impl SanitizerReport {
Some(SanitizerReport {
sanitizer,
kind,
+ fault_address: fault_address_in(lines[header_index]),
frames: parse_frames(&lines[header_index + 1..]),
})
}
@@ -80,6 +84,11 @@ impl SanitizerReport {
&self.frames
}
+ #[must_use]
+ pub fn fault_address(&self) -> Option<u64> {
+ self.fault_address
+ }
+
#[must_use]
pub fn is_undefined_behavior(&self) -> bool {
self.sanitizer == UBSAN_SANITIZER
@@ -180,6 +189,20 @@ fn normalize_kind(remainder: &str) -> String {
redact_addresses(remainder[..cut].trim())
}
+fn fault_address_in(header: &str) -> Option<u64> {
+ let after = [KIND_ON_UNKNOWN_ADDRESS, KIND_ON_ADDRESS]
+ .iter()
+ .filter_map(|marker| header.find(marker).map(|at| at + marker.len()))
+ .min()?;
+ let rest = header[after..].trim_start();
+ let digits: String = rest
+ .strip_prefix(HEX_LITERAL_PREFIX)?
+ .chars()
+ .take_while(char::is_ascii_hexdigit)
+ .collect();
+ u64::from_str_radix(&digits, HEX_RADIX).ok()
+}
+
fn redact_addresses(text: &str) -> String {
let chars: Vec<char> = text.chars().collect();
let mut out = String::with_capacity(text.len());
@@ -760,6 +783,68 @@ ubsanlab.c:26:15: runtime error: addition of unsigned offset to 0x558d605072e0 o
assert_eq!(redact_addresses("0xdeadbeef"), REDACTED_ADDRESS);
}
+ const SEGV_AT_OFFSET: &str = "\
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263357==ERROR: AddressSanitizer: SEGV on unknown address 0x000000009000 (pc 0x561a3d7fa902 bp 0x7ffd11829e70 sp 0x7ffd11829e10 T0)
+==263357==The signal is caused by a WRITE memory access.
+ #0 0x561a3d7fa902 in fault /work/nulllab.c:18:5
+";
+
+ #[test]
+ fn the_fault_address_survives_the_redaction_that_removes_it_from_kind() {
+ let report = SanitizerReport::parse(SEGV_AT_OFFSET).unwrap();
+ assert_eq!(report.kind(), "SEGV");
+ assert_eq!(
+ report.fault_address(),
+ Some(0x9000),
+ "M7.4 redacts every 0x run out of kind to keep the dedup key stable, so the address has to be captured before that and carried separately"
+ );
+ }
+
+ #[test]
+ fn the_fault_address_is_read_from_the_on_address_grammar_too() {
+ let report = SanitizerReport::parse(
+ "==1==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000018 at pc 0x4a1\n",
+ )
+ .unwrap();
+ assert_eq!(report.fault_address(), Some(0x0000_6020_0000_0018));
+ }
+
+ #[test]
+ fn a_grammar_that_states_no_fault_address_yields_none() {
+ let double_free = SanitizerReport::parse(
+ "==1==ERROR: AddressSanitizer: attempting double-free on 0x7b6189de0040 in thread T0:\n #0 0x1 in free /a.c:1:1\n",
+ )
+ .unwrap();
+ assert_eq!(
+ double_free.fault_address(),
+ None,
+ "a freed heap pointer is not a fault address, and reading it as one would file every double-free as a wild write"
+ );
+ assert_eq!(
+ SanitizerReport::parse(UBSAN_ONLY).unwrap().fault_address(),
+ None
+ );
+ assert_eq!(
+ SanitizerReport::parse(LEAK_REPORT).unwrap().fault_address(),
+ None
+ );
+ }
+
+ #[test]
+ fn a_null_fault_address_is_zero_and_not_absent() {
+ let report = SanitizerReport::parse(
+ "==1==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x1 bp 0x2 sp 0x3 T0)\n",
+ )
+ .unwrap();
+ assert_eq!(
+ report.fault_address(),
+ Some(0),
+ "a genuine null dereference must be distinguishable from a report that states no address at all"
+ );
+ }
+
#[test]
fn anchored_lines_drop_everything_above_the_header() {
let anchored = anchored_lines(PNG003_CANARY).unwrap();
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
new file mode 100644
index 00000000..3bb87ede
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/boundary.rs
@@ -0,0 +1,94 @@
+// ©AngelaMos | 2026
+// boundary.rs
+
+pub const NULL_DEREFERENCE_BOUNDARY: u64 = 32 * 1024;
+
+pub const CLUSTERFUZZ_BOUNDARY: u64 = 4 * 1024;
+pub const LIBCASR_BOUNDARY: u64 = 64 * 1024;
+
+const _: () = assert!(CLUSTERFUZZ_BOUNDARY < NULL_DEREFERENCE_BOUNDARY);
+const _: () = assert!(NULL_DEREFERENCE_BOUNDARY < LIBCASR_BOUNDARY);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum FaultAddress {
+ Absent,
+ NearNull(u64),
+ Wild(u64),
+}
+
+impl FaultAddress {
+ #[must_use]
+ pub fn of(address: Option<u64>) -> Self {
+ match address {
+ None => Self::Absent,
+ Some(value) if value < NULL_DEREFERENCE_BOUNDARY => Self::NearNull(value),
+ Some(value) => Self::Wild(value),
+ }
+ }
+
+ #[must_use]
+ pub fn is_security_relevant(self) -> bool {
+ !matches!(self, Self::NearNull(_))
+ }
+
+ #[must_use]
+ pub fn address(self) -> Option<u64> {
+ match self {
+ Self::Absent => None,
+ Self::NearNull(value) | Self::Wild(value) => Some(value),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const BAND_ADDRESS: u64 = 0x9000;
+
+ const _: () = assert!(BAND_ADDRESS > CLUSTERFUZZ_BOUNDARY);
+ const _: () = assert!(BAND_ADDRESS > NULL_DEREFERENCE_BOUNDARY);
+ const _: () = assert!(BAND_ADDRESS < LIBCASR_BOUNDARY);
+
+ #[test]
+ fn the_adopted_boundary_is_chromiums_and_not_the_one_libcasr_would_have_supplied() {
+ assert_eq!(
+ NULL_DEREFERENCE_BOUNDARY,
+ 32 * 1024,
+ "ClusterFuzz uses 4 KiB, libcasr 64 KiB, Chromium 32 KiB; the ordering of the three is asserted at compile time and this pins which one lisdex adopted"
+ );
+ }
+
+ #[test]
+ fn an_offset_inside_a_plausible_struct_is_not_a_security_finding() {
+ assert_eq!(FaultAddress::of(Some(0)), FaultAddress::NearNull(0));
+ assert_eq!(FaultAddress::of(Some(0x10)), FaultAddress::NearNull(0x10));
+ assert!(!FaultAddress::of(Some(0x10)).is_security_relevant());
+ }
+
+ #[test]
+ fn the_band_the_three_systems_disagree_about_resolves_to_security() {
+ let band = BAND_ADDRESS;
+ assert_eq!(FaultAddress::of(Some(band)), FaultAddress::Wild(band));
+ assert!(
+ FaultAddress::of(Some(band)).is_security_relevant(),
+ "libcasr calls 36 KiB near-null and would file this as non-security; ClusterFuzz at 4 KiB and Chromium at 32 KiB both call it security, and lisdex follows them"
+ );
+ }
+
+ #[test]
+ fn the_boundary_itself_is_already_beyond_it() {
+ assert!(FaultAddress::of(Some(NULL_DEREFERENCE_BOUNDARY)).is_security_relevant());
+ assert!(!FaultAddress::of(Some(NULL_DEREFERENCE_BOUNDARY - 1)).is_security_relevant());
+ }
+
+ #[test]
+ fn a_report_with_no_fault_address_answers_nothing_rather_than_safe() {
+ assert_eq!(FaultAddress::of(None), FaultAddress::Absent);
+ assert!(
+ FaultAddress::of(None).is_security_relevant(),
+ "only a measured small offset earns the non-security verdict; an absent address must never be read as one"
+ );
+ assert_eq!(FaultAddress::of(None).address(), None);
+ }
+}
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/classify.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/classify.rs
index ec8a96f8..c43229ed 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/classify.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/classify.rs
@@ -5,6 +5,7 @@ use libcasr::asan::AsanContext;
use libcasr::severity::Severity as CasrSeverity;
use lisdex_core::report::{self, SanitizerReport};
+use crate::boundary::FaultAddress;
use crate::severity::Severity;
const DOUBLE_FREE_CLASS: &str = "double-free";
@@ -21,6 +22,7 @@ pub struct Classification {
severity: Severity,
class: String,
decided_by: DecidedBy,
+ fault_address: FaultAddress,
}
impl Classification {
@@ -38,16 +40,28 @@ impl Classification {
pub fn decided_by(&self) -> DecidedBy {
self.decided_by
}
+
+ #[must_use]
+ pub fn fault_address(&self) -> FaultAddress {
+ self.fault_address
+ }
+
+ #[must_use]
+ pub fn is_security_relevant(&self) -> bool {
+ self.fault_address.is_security_relevant()
+ }
}
#[must_use]
pub fn classify(text: &str) -> Option<Classification> {
let parsed = SanitizerReport::parse(text)?;
+ let fault_address = FaultAddress::of(parsed.fault_address());
if parsed.is_undefined_behavior() {
return Some(Classification {
severity: Severity::Undefined,
class: parsed.kind().to_owned(),
decided_by: DecidedBy::Lisdex,
+ fault_address,
});
}
@@ -61,6 +75,7 @@ pub fn classify(text: &str) -> Option<Classification> {
severity: DOUBLE_FREE_SEVERITY,
class: class.short_description,
decided_by: DecidedBy::Lisdex,
+ fault_address,
});
}
@@ -68,6 +83,7 @@ pub fn classify(text: &str) -> Option<Classification> {
severity,
class: class.short_description,
decided_by: DecidedBy::Casr,
+ fault_address,
})
}
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/lib.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/lib.rs
index dc131f42..27eaa500 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/lib.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/src/lib.rs
@@ -1,5 +1,6 @@
// ©AngelaMos | 2026
// lib.rs
+pub mod boundary;
pub mod classify;
pub mod severity;
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_band.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_band.txt
new file mode 100644
index 00000000..0367a5a8
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_band.txt
@@ -0,0 +1,17 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263356==ERROR: AddressSanitizer: SEGV on unknown address 0x000000009000 (pc 0x563b02b8594a bp 0x7fffe2c21d60 sp 0x7fffe2c21d00 T0)
+==263356==The signal is caused by a READ memory access.
+ #0 0x563b02b8594a (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7fce13d881c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7fce13d8828a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x563b02a9d364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263356==Register values:
+rax = 0x0000000000009000 rbx = 0x00007fffe2c21e88 rcx = 0x00000000ffffffff rdx = 0x0000563b02b99440
+rdi = 0x0000563b02b858c8 rsi = 0x00007fffe2c23c86 rbp = 0x00007fffe2c21d60 rsp = 0x00007fffe2c21d00
+ r8 = 0x00000000f9f9f901 r9 = 0x00000ac7e056b288 r10 = 0x000010007c57c790 r11 = 0x00000ac7e056b288
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x0000563b02bbe5a0 r15 = 0x00007fce140e1000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263356==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_far.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_far.txt
new file mode 100644
index 00000000..3cc5a6e6
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_far.txt
@@ -0,0 +1,17 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263358==ERROR: AddressSanitizer: SEGV on unknown address 0x000000100000 (pc 0x564c9538394a bp 0x7ffcb4d49dd0 sp 0x7ffcb4d49d70 T0)
+==263358==The signal is caused by a READ memory access.
+ #0 0x564c9538394a (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7fb664ab51c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7fb664ab528a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x564c9529b364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263358==Register values:
+rax = 0x0000000000100000 rbx = 0x00007ffcb4d49ef8 rcx = 0x00000000ffffffff rdx = 0x0000564c95397440
+rdi = 0x0000564c953838c8 rsi = 0x00007ffcb4d4bc86 rbp = 0x00007ffcb4d49dd0 rsp = 0x00007ffcb4d49d70
+ r8 = 0x00000000f9f9f901 r9 = 0x00000aca12a6ae88 r10 = 0x00001000169a1790 r11 = 0x00000aca12a6ae88
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x0000564c953bc5a0 r15 = 0x00007fb664e0e000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263358==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_small.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_small.txt
new file mode 100644
index 00000000..342c5bfd
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_read_small.txt
@@ -0,0 +1,18 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263354==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000010 (pc 0x55fead64d94a bp 0x7ffcf90f0e90 sp 0x7ffcf90f0e30 T0)
+==263354==The signal is caused by a READ memory access.
+==263354==Hint: address points to the zero page.
+ #0 0x55fead64d94a (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7f8dd57961c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7f8dd579628a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x55fead565364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263354==Register values:
+rax = 0x0000000000000010 rbx = 0x00007ffcf90f0fb8 rcx = 0x00000000ffffffff rdx = 0x000055fead661440
+rdi = 0x000055fead64d8c8 rsi = 0x00007ffcf90f2c86 rbp = 0x00007ffcf90f0e90 rsp = 0x00007ffcf90f0e30
+ r8 = 0x00000000f9f9f901 r9 = 0x00000ac055ac4288 r10 = 0x000010001f216590 r11 = 0x00000ac055ac4288
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x000055fead6865a0 r15 = 0x00007f8dd5aef000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x11494a) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263354==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_band.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_band.txt
new file mode 100644
index 00000000..456cfe64
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_band.txt
@@ -0,0 +1,17 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263357==ERROR: AddressSanitizer: SEGV on unknown address 0x000000009000 (pc 0x561a3d7fa902 bp 0x7ffd11829e70 sp 0x7ffd11829e10 T0)
+==263357==The signal is caused by a WRITE memory access.
+ #0 0x561a3d7fa902 (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7fcd3d8fd1c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7fcd3d8fd28a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x561a3d712364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263357==Register values:
+rax = 0x0000000000009000 rbx = 0x00007ffd11829f98 rcx = 0x0000000000000000 rdx = 0x0000561a3d80e440
+rdi = 0x0000561a3d7fa8c8 rsi = 0x00007ffd1182ac85 rbp = 0x00007ffd11829e70 rsp = 0x00007ffd11829e10
+ r8 = 0x00000000f9f9f901 r9 = 0x00000ac3c7af9c88 r10 = 0x00001000222fd591 r11 = 0x00000ac3c7af9c88
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x0000561a3d8335a0 r15 = 0x00007fcd3dc56000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263357==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_far.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_far.txt
new file mode 100644
index 00000000..9a3630b4
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_far.txt
@@ -0,0 +1,17 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263359==ERROR: AddressSanitizer: SEGV on unknown address 0x000000100000 (pc 0x5642f408f902 bp 0x7ffe86b1e090 sp 0x7ffe86b1e030 T0)
+==263359==The signal is caused by a WRITE memory access.
+ #0 0x5642f408f902 (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7f1f6ccdc1c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7f1f6ccdc28a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x5642f3fa7364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263359==Register values:
+rax = 0x0000000000100000 rbx = 0x00007ffe86b1e1b8 rcx = 0x0000000000000000 rdx = 0x00005642f40a3440
+rdi = 0x00005642f408f8c8 rsi = 0x00007ffe86b1fc85 rbp = 0x00007ffe86b1e090 rsp = 0x00007ffe86b1e030
+ r8 = 0x00000000f9f9f901 r9 = 0x00000ac8de80c688 r10 = 0x0000100050d5bf91 r11 = 0x00000ac8de80c688
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x00005642f40c85a0 r15 = 0x00007f1f6d035000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263359==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_small.txt b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_small.txt
new file mode 100644
index 00000000..e92d1c7e
--- /dev/null
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/fixtures/segv_write_small.txt
@@ -0,0 +1,18 @@
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==263355==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000010 (pc 0x559bad957902 bp 0x7ffd621682d0 sp 0x7ffd62168270 T0)
+==263355==The signal is caused by a WRITE memory access.
+==263355==Hint: address points to the zero page.
+ #0 0x559bad957902 (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+ #1 0x7fc07b3c21c9 (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #2 0x7fc07b3c228a (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 8e9fd827446c24067541ac5390e6f527fb5947bb)
+ #3 0x559bad86f364 (/work/target/doc07lab/nulllab+0x2c364) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+
+==263355==Register values:
+rax = 0x0000000000000010 rbx = 0x00007ffd621683f8 rcx = 0x0000000000000000 rdx = 0x0000559bad96b440
+rdi = 0x0000559bad9578c8 rsi = 0x00007ffd62169c85 rbp = 0x00007ffd621682d0 rsp = 0x00007ffd62168270
+ r8 = 0x00000000f9f9f901 r9 = 0x00000ab3f5b25688 r10 = 0x000010002c425391 r11 = 0x00000ab3f5b25688
+r12 = 0x0000000000000003 r13 = 0x0000000000000000 r14 = 0x0000559bad9905a0 r15 = 0x00007fc07b71b000
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV (/work/target/doc07lab/nulllab+0x114902) (BuildId: 41eac7badb2160a51baec6e0ff9e9f4bbc5a3f32)
+==263355==ABORTING
diff --git a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/real_reports.rs b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/real_reports.rs
index f46f08ce..6c0691c6 100644
--- a/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/real_reports.rs
+++ b/PROJECTS/advanced/zero-day-vulnerability-scanner/crates/lisdex-triage/tests/real_reports.rs
@@ -1,9 +1,28 @@
// ©AngelaMos | 2026
// real_reports.rs
+use lisdex_triage::boundary::{FaultAddress, LIBCASR_BOUNDARY, NULL_DEREFERENCE_BOUNDARY};
use lisdex_triage::classify::{DecidedBy, classify};
use lisdex_triage::severity::Severity;
+const BAND_ADDRESS: u64 = 0x9000;
+const SMALL_ADDRESS: u64 = 0x10;
+const FAR_ADDRESS: u64 = 0x0010_0000;
+
+const _: () = assert!(
+ BAND_ADDRESS > NULL_DEREFERENCE_BOUNDARY && BAND_ADDRESS < LIBCASR_BOUNDARY,
+ "the fixture must sit inside the band the two boundaries disagree about, or it controls nothing"
+);
+
+const ADDRESS_CASES: [(&str, u64, bool); 6] = [
+ ("segv_read_small", SMALL_ADDRESS, false),
+ ("segv_write_small", SMALL_ADDRESS, false),
+ ("segv_read_band", BAND_ADDRESS, true),
+ ("segv_write_band", BAND_ADDRESS, true),
+ ("segv_read_far", FAR_ADDRESS, true),
+ ("segv_write_far", FAR_ADDRESS, true),
+];
+
const FIXTURES: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures");
const EXPECTED: [(&str, Severity, &str, DecidedBy); 13] = [
@@ -119,6 +138,74 @@ fn every_real_captured_report_classifies_as_hand_labeled() {
);
}
+#[test]
+fn the_fault_address_is_read_off_every_real_segv() {
+ for (name, address, _) in ADDRESS_CASES {
+ let classification = classify(&read(name)).expect(name);
+ assert_eq!(
+ classification.fault_address().address(),
+ Some(address),
+ "{name} must yield its real fault address; M7.4 redacts it out of kind, so nothing else in the parsed report carries it"
+ );
+ }
+}
+
+#[test]
+fn the_boundary_splits_the_real_segv_corpus_where_chromium_says_it_should() {
+ for (name, address, security) in ADDRESS_CASES {
+ let classification = classify(&read(name)).expect(name);
+ assert_eq!(
+ classification.is_security_relevant(),
+ security,
+ "{name} faults at {address:#x}, and the adopted boundary is {NULL_DEREFERENCE_BOUNDARY}"
+ );
+ }
+}
+
+#[test]
+fn the_disagreement_band_is_the_control_and_libcasr_still_calls_it_near_null() {
+ let band = classify(&read("segv_write_band")).expect("segv_write_band");
+ assert_eq!(
+ band.fault_address(),
+ FaultAddress::Wild(BAND_ADDRESS),
+ "an unread address defaults to security-relevant, so this control must see the real address or it passes for the wrong reason"
+ );
+ assert!(
+ band.class().contains("NearNull"),
+ "the fixture must reproduce the disagreement: libcasr's own boundary is 64 KiB, so it still classes this as near-null: {}",
+ band.class()
+ );
+ assert!(
+ band.is_security_relevant(),
+ "lisdex adopted Chromium's 32 KiB deliberately, so a fault libcasr calls near-null is still filed as security"
+ );
+}
+
+#[test]
+fn a_write_near_null_is_rated_above_a_read_near_null() {
+ let write = classify(&read("segv_write_small")).expect("segv_write_small");
+ let read_only = classify(&read("segv_read_small")).expect("segv_read_small");
+ assert_eq!(write.severity(), Severity::ProbablyExploitable);
+ assert_eq!(read_only.severity(), Severity::NotExploitable);
+ assert!(
+ !write.is_security_relevant(),
+ "the severity tier and the security question are different axes; a write near null is the more dangerous of the two and is still a small fixed offset"
+ );
+}
+
+#[test]
+fn a_crash_with_no_address_grammar_carries_no_fault_address() {
+ for name in ["dfree", "ub_shift", "leak"] {
+ let classification = classify(&read(name)).expect(name);
+ assert_eq!(
+ classification.fault_address(),
+ FaultAddress::Absent,
+ "{name} has no `on address` grammar, and a heap pointer or a prose address is not a fault address"
+ );
+ assert!(classification.is_security_relevant());
+ }
+}
+
#[test]
fn the_fixtures_are_verbatim_captures_and_not_tidied_text() {
let untidy: Vec<&str> = EXPECTED
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 554563d5..8d278e2a 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
@@ -36,6 +36,7 @@ use lisdex_triage::classify::classify;
const UNKNOWN_TARGET: &str = "unknown";
const UNPARSED_KIND: &str = "unparsed";
const UNCLASSIFIED_SEVERITY: &str = "UNCLASSIFIED";
+const NON_SECURITY_MARKER: &str = "/non-security";
const NO_STACK_HASH: &str = "none";
const UNKEYED_MARKER: &str = "unkeyed";
const STACK_HASH_SHORT_LEN: usize = 16;
@@ -1200,10 +1201,17 @@ fn crash_line(crash: &Crash) -> String {
let report = SanitizerReport::parse(crash.sanitizer_report());
let classification = classify(crash.sanitizer_report());
format!(
- "{} {} bytes {} {}",
+ "{}{} {} bytes {} {}",
classification
.as_ref()
.map_or(UNCLASSIFIED_SEVERITY, |c| c.severity().as_str()),
+ classification
+ .as_ref()
+ .map_or("", |c| if c.is_security_relevant() {
+ ""
+ } else {
+ NON_SECURITY_MARKER
+ }),
crash.input().len(),
classification.as_ref().map_or_else(
|| report.as_ref().map_or(UNPARSED_KIND, |r| r.kind()),
@@ -1350,13 +1358,20 @@ fn crashes(args: &CrashesArgs) -> Result<(), Box<dyn Error>> {
let report = SanitizerReport::parse(crash.sanitizer_report());
let classification = classify(crash.sanitizer_report());
println!(
- " stack_hash {} input {} bytes kind {} severity {} class {}",
+ " stack_hash {} input {} bytes kind {} severity {}{} class {}",
crash.stack_hash().unwrap_or(NO_STACK_HASH),
crash.input().len(),
report.as_ref().map_or(UNPARSED_KIND, |r| r.kind()),
classification
.as_ref()
.map_or(UNCLASSIFIED_SEVERITY, |c| c.severity().as_str()),
+ classification
+ .as_ref()
+ .map_or("", |c| if c.is_security_relevant() {
+ ""
+ } else {
+ NON_SECURITY_MARKER
+ }),
classification.as_ref().map_or(UNPARSED_KIND, |c| c.class())
);
if let Some(report) = report {