use crate::analyzers::{Analyzer, Annotation, AnnotationKind, Limits, RecoveredAnnotationBudget};
use crate::binary::Binary;
use std::collections::HashSet;
const MIN_STRING_LABEL_BYTES: usize = 1;
const MIN_STRING_OWNED_TEXT_BYTES: usize = 1 + MIN_STRING_LABEL_BYTES;
#[cfg(test)]
thread_local! {
static CANDIDATE_CONTENT_READS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
#[cfg(test)]
fn reset_candidate_content_reads() {
CANDIDATE_CONTENT_READS.with(|reads| reads.set(0));
}
#[cfg(test)]
fn candidate_content_reads() -> usize {
CANDIDATE_CONTENT_READS.with(std::cell::Cell::get)
}
#[cfg(test)]
fn record_candidate_content_read() {
CANDIDATE_CONTENT_READS.with(|reads| reads.set(reads.get().saturating_add(1)));
}
#[derive(Debug, Clone)]
pub struct StringsAnalyzer {
pub limits: Limits,
}
impl Default for StringsAnalyzer {
fn default() -> Self {
Self::new()
}
}
impl StringsAnalyzer {
#[must_use]
pub fn new() -> Self {
Self {
limits: Limits::default(),
}
}
#[must_use]
pub const fn with_limits(limits: Limits) -> Self {
Self { limits }
}
}
impl Analyzer for StringsAnalyzer {
fn name(&self) -> &'static str {
"strings"
}
fn analyze(&self, bin: &Binary) -> Vec<Annotation> {
let mut out = Vec::new();
let ws = if bin.is_64 { 8usize } else { 4 };
let max = self.limits.max_string_len;
let mut budget = RecoveredAnnotationBudget::for_string_sections(bin, ws);
let mut seen_slices = HashSet::new();
for (section_index, sec) in bin.sections().iter().enumerate() {
if !bin.is_string_section_index(section_index) {
continue;
}
scan_section(bin, sec, ws, max, &mut budget, &mut seen_slices, &mut out);
if budget.cannot_fit_any_annotation(MIN_STRING_OWNED_TEXT_BYTES) {
break;
}
}
out
}
}
fn scan_section(
bin: &Binary,
sec: &crate::binary::Section,
ws: usize,
max: usize,
budget: &mut RecoveredAnnotationBudget,
seen_slices: &mut HashSet<(u64, u64)>,
out: &mut Vec<Annotation>,
) {
let data = sec.data.as_slice();
if data.len() < ws.saturating_mul(2) {
return;
}
let mut off = 0usize;
while off.checked_add(ws * 2).is_some_and(|e| e <= data.len()) {
if budget.cannot_fit_any_annotation(MIN_STRING_OWNED_TEXT_BYTES) {
break;
}
let Some(lookup) = sec.vaddr.checked_add(off as u64) else {
break;
};
let Some(ptr) = bin.read_ptr(lookup) else {
off = off.saturating_add(ws);
continue;
};
let Some(len_vaddr) = lookup.checked_add(ws as u64) else {
off = off.saturating_add(ws);
continue;
};
let Some(len) = bin.read_ptr(len_vaddr) else {
off = off.saturating_add(ws);
continue;
};
let Ok(text_bytes) = usize::try_from(len) else {
off = off.saturating_add(ws);
continue;
};
if text_bytes == 0 || text_bytes > max {
off = off.saturating_add(ws);
continue;
}
if !budget.can_fit_annotation_with_minimum_text(minimum_owned_text_bytes(text_bytes)) {
off = off.saturating_add(ws);
continue;
}
if !bin.vaddr_in_string_section(ptr, len) {
off = off.saturating_add(ws);
continue;
}
if seen_slices.contains(&(ptr, len)) {
off = off.saturating_add(ws);
continue;
}
#[cfg(test)]
record_candidate_content_read();
let Some(bytes) = bin.read_at_vaddr(ptr, text_bytes) else {
off = off.saturating_add(ws);
continue;
};
if !is_reasonable_string(bytes) {
off = off.saturating_add(ws);
continue;
}
let Ok(text) = std::str::from_utf8(bytes) else {
off = off.saturating_add(ws);
continue;
};
let text_bytes = text.len();
let label_len = text
.char_indices()
.nth(80)
.map_or(text_bytes, |(offset, _)| {
offset.saturating_add('…'.len_utf8())
});
let owned_text_bytes = text_bytes.saturating_add(label_len);
if !budget.try_consume(owned_text_bytes) {
off = off.saturating_add(ws);
continue;
}
seen_slices.insert((ptr, len));
let label = truncate(text, 80);
out.push(Annotation {
vaddr: ptr,
kind: AnnotationKind::String,
label,
comment: Some(text.to_owned()),
});
off = off.saturating_add(ws);
}
}
const fn minimum_owned_text_bytes(comment_bytes: usize) -> usize {
comment_bytes.saturating_add(MIN_STRING_LABEL_BYTES)
}
fn is_reasonable_string(b: &[u8]) -> bool {
let Ok(s) = std::str::from_utf8(b) else {
return false;
};
if s.is_empty() {
return false;
}
!s.chars().any(char::is_control) && s.chars().any(char::is_alphanumeric)
}
fn truncate(s: &str, n: usize) -> String {
if s.chars().count() <= n {
s.to_string()
} else {
let mut out: String = s.chars().take(n).collect();
out.push('\u{2026}');
out
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::binary::{Binary, BinaryFormat as Bf, Section};
#[test]
fn empty_string_rejected() {
assert!(!is_reasonable_string(b""));
assert!(!is_reasonable_string(b"\x00\x00\x00"));
}
#[test]
fn control_chars_rejected() {
assert!(!is_reasonable_string(b"hello\x00world"));
assert!(!is_reasonable_string(b"hello\nworld"));
}
#[test]
fn alphanumeric_required() {
assert!(is_reasonable_string(b"hello world"));
assert!(is_reasonable_string(b"src/foo.rs:42"));
assert!(is_reasonable_string(b"v1.2.3-rc1"));
assert!(is_reasonable_string(b"~/path/to/{x}"));
}
#[test]
fn punctuation_only_rejected() {
assert!(!is_reasonable_string(b"--"));
assert!(!is_reasonable_string(b"::"));
assert!(!is_reasonable_string(b"..."));
assert!(!is_reasonable_string(b"()"));
}
#[test]
fn truncate_keeps_ellipsis() {
let t = truncate(&"a".repeat(120), 10);
assert!(t.chars().count() <= 11);
assert!(t.ends_with('\u{2026}'));
}
#[test]
fn analyzer_name_returns_strings() {
assert_eq!(StringsAnalyzer::new().name(), "strings");
}
#[test]
fn scan_accepts_data_exactly_ws2() {
let sv = 0x4000u64;
let text = b"hello";
let mut rd = ptr_len(sv, text.len() as u64);
rd.pop(); let bin = string_bin(rd, sv, text.to_vec());
assert!(
StringsAnalyzer::new().analyze(&bin).is_empty(),
"section with 15 bytes (< ws*2=16) must be rejected"
);
}
fn string_bin(rodata_data: Vec<u8>, str_vaddr: u64, str_data: Vec<u8>) -> Binary {
Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".rodata".into(),
vaddr: 0x1000,
size: rodata_data.len() as u64,
data: rodata_data,
},
Section {
name: ".rodata.str".into(),
vaddr: str_vaddr,
size: str_data.len() as u64,
data: str_data,
},
],
vec![],
vec![0, 1],
)
}
fn ptr_len(ptr: u64, len: u64) -> Vec<u8> {
let mut b = Vec::with_capacity(16);
b.extend_from_slice(&ptr.to_le_bytes());
b.extend_from_slice(&len.to_le_bytes());
b
}
#[test]
fn scan_finds_string_at_exact_min_section_size() {
let sv = 0x4000u64;
let text = b"hello";
let rd = ptr_len(sv, text.len() as u64);
assert_eq!(rd.len(), 16);
let bin = string_bin(rd, sv, text.to_vec());
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].label, "hello");
}
#[test]
fn scan_rejects_section_smaller_than_min() {
let sv = 0x4000u64;
let mut rd = ptr_len(sv, 5);
rd.pop();
let bin = string_bin(rd, sv, b"hello".to_vec());
assert!(StringsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_rejects_zero_length_string() {
let sv = 0x4000u64;
let rd = ptr_len(sv, 0);
let bin = string_bin(rd, sv, b"hello".to_vec());
assert!(StringsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_len_at_max_boundary() {
let lim = Limits {
max_string_len: 5,
..Limits::default()
};
let sv = 0x4000u64;
let text = b"hello";
let rd = ptr_len(sv, text.len() as u64);
let bin = string_bin(rd, sv, text.to_vec());
assert_eq!(StringsAnalyzer::with_limits(lim).analyze(&bin).len(), 1);
}
#[test]
fn scan_rejects_len_above_max() {
let lim = Limits {
max_string_len: 3,
..Limits::default()
};
let sv = 0x4000u64;
let text = b"hello";
let rd = ptr_len(sv, text.len() as u64);
let bin = string_bin(rd, sv, text.to_vec());
assert!(StringsAnalyzer::with_limits(lim).analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_len_one() {
let sv = 0x4000u64;
let text = b"x";
let rd = ptr_len(sv, 1);
let bin = string_bin(rd, sv, text.to_vec());
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1, "len=1 with alphanumeric must be accepted");
}
#[test]
fn scan_finds_string_in_comma_qualified_mach_sections() {
let sv = 0x4000u64;
let text = b"hello";
let bin = Binary::from_test_parts(
Bf::MachO,
true,
true,
vec![
Section {
name: "__DATA_CONST.__const,regular".into(),
vaddr: 0x1000,
size: 16,
data: ptr_len(sv, text.len() as u64),
},
Section {
name: "__TEXT.__cstring,cstring_literals".into(),
vaddr: sv,
size: text.len() as u64,
data: text.to_vec(),
},
],
vec![],
vec![0, 1],
);
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].label, "hello");
}
#[test]
fn scan_finds_string_in_exact_rodata1() {
let vaddr = 0x1000u64;
let string_vaddr = vaddr + 16;
let mut data = ptr_len(string_vaddr, 5);
data.extend_from_slice(b"hello");
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![Section {
name: ".rodata1".into(),
vaddr,
size: data.len() as u64,
data,
}],
vec![],
vec![0],
);
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].label, "hello");
}
#[test]
fn scan_honors_forced_string_section_classification() {
let sv = 0x4000u64;
let text = b"hello";
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".custom_headers".into(),
vaddr: 0x1000,
size: 16,
data: ptr_len(sv, text.len() as u64),
},
Section {
name: ".custom_strings".into(),
vaddr: sv,
size: text.len() as u64,
data: text.to_vec(),
},
],
vec![],
vec![0, 1],
);
assert_eq!(StringsAnalyzer::new().analyze(&bin).len(), 1);
}
#[test]
fn scan_does_not_override_an_empty_forced_classification() {
let sv = 0x4000u64;
let text = b"hello";
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".rodata".into(),
vaddr: 0x1000,
size: 16,
data: ptr_len(sv, text.len() as u64),
},
Section {
name: ".rodata.str".into(),
vaddr: sv,
size: text.len() as u64,
data: text.to_vec(),
},
],
vec![],
vec![],
);
assert!(StringsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_deduplicates_repeated_slice_before_allocating_text() {
let sv = 0x4000u64;
let text = b"hello";
let mut headers = ptr_len(sv, text.len() as u64);
headers.extend_from_slice(&ptr_len(sv, text.len() as u64));
let bin = string_bin(headers, sv, text.to_vec());
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].comment.as_deref(), Some("hello"));
}
#[test]
fn scan_caps_aggregate_owned_text_against_backing_bytes() {
let sv = 0x4000u64;
let text = vec![b'a'; 4096];
let mut headers = Vec::new();
for offset in 0..3u64 {
headers.extend_from_slice(&ptr_len(sv + offset, 4000));
}
let backing_bytes = headers.len() + text.len();
let bin = string_bin(headers, sv, text);
let anns = StringsAnalyzer::new().analyze(&bin);
let emitted_text = anns.iter().fold(0usize, |total, annotation| {
total
.saturating_add(annotation.label.len())
.saturating_add(annotation.comment.as_deref().map_or(0, str::len))
});
assert_eq!(anns.len(), 2);
assert!(emitted_text <= backing_bytes.saturating_mul(2));
}
#[test]
fn scan_skips_over_budget_strings_before_content_read() {
let sv = 0x4000u64;
let text = vec![b'a'; 4096];
let mut headers = Vec::new();
for offset in 0..4u64 {
headers.extend_from_slice(&ptr_len(sv + offset, 4000));
}
let bin = string_bin(headers, sv, text);
reset_candidate_content_reads();
let anns = StringsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 2);
assert_eq!(candidate_content_reads(), 2);
assert!(anns.iter().all(|annotation| annotation
.comment
.as_deref()
.is_some_and(|text| text.len() == 4000)));
}
#[test]
fn scan_checked_add_len_address_overflow_does_not_wrap() {
let vaddr = u64::MAX - 7;
let mut data = ptr_len(0x4000, 0);
data[8..].fill(0xff);
let bin = Binary {
path: None,
format: Bf::Elf,
arch: "x86_64".into(),
is_64: true,
little_endian: true,
bytes: vec![],
sections: vec![
Section {
name: ".rodata".into(),
vaddr,
size: 16,
data,
},
Section {
name: ".data".into(),
vaddr: 0,
size: 8,
data: 5u64.to_le_bytes().to_vec(),
},
Section {
name: ".rodata.str".into(),
vaddr: 0x4000,
size: 5,
data: b"hello".to_vec(),
},
],
symbols: vec![],
sec_by_vaddr: vec![(0, 8, 1), (0x4000, 0x4005, 2), (vaddr, u64::MAX, 0)],
string_sections: vec![0, 2],
};
assert!(StringsAnalyzer::new().analyze(&bin).is_empty());
}
}