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
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.rsindex 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 oassert_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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.txtnew file mode 100644index 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==ABORTINGdiff --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.txtnew file mode 100644index 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==ABORTINGdiff --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.txtnew file mode 100644index 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==ABORTINGdiff --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.txtnew file mode 100644index 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==ABORTINGdiff --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.txtnew file mode 100644index 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==ABORTINGdiff --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.txtnew file mode 100644index 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==ABORTINGdiff --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.rsindex 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> = EXPECTEDdiff --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 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 {