Implement ASCII String Extractor with Configurable Length Filtering

[unclesp1d3r]

Summary

Implement the foundational ASCII string extraction module that scans binary data for printable ASCII character sequences (0x20-0x7E) and returns them as FoundString objects with configurable minimum length filtering.

Context

ASCII extraction is the foundational encoding type for StringyMcStringFace's string extraction pipeline. Unlike the traditional strings command which blindly extracts all printable sequences, this implementation will:

• Be section-aware (integrate with SectionInfo from the container parsing)
• Return properly structured FoundString objects with metadata (offset, RVA, section name, encoding type)
• Support configurable minimum length to reduce noise from random byte sequences
• Serve as the reference implementation for future encodings (UTF-8, UTF-16LE, UTF-16BE)

The ASCII extractor will be the first concrete implementation of the string extraction framework and will be used by all binary formats (ELF, PE, Mach-O).

Requirements

• Requirement 2.1: Implement basic string extraction for ASCII encoding
• Must scan byte sequences for contiguous printable ASCII characters (0x20-0x7E)
• Must support configurable minimum length threshold (default: 4 characters)
• Must return FoundString objects as defined in src/types.rs
• Must properly populate metadata fields: offset, section name, encoding, length, source
• Must handle section boundaries correctly (don't span strings across sections)

Proposed Solution

File Structure

Create src/extraction/ascii.rs with the following components:

Core Functions

1. extract_ascii_strings(data: &[u8], config: &ExtractionConfig) -> Vec<FoundString>

   • Main extraction function
   • Scans byte slice for printable ASCII runs
   • Filters by minimum length
   • Returns vector of FoundString objects

2. is_printable_ascii(byte: u8) -> bool

   • Helper to check if byte is in printable range (0x20-0x7E)
   • Inline for performance

3. extract_from_section(section: &SectionInfo, data: &[u8], config: &ExtractionConfig) -> Vec<FoundString>

   • Section-aware extraction wrapper
   • Calculates correct offsets and RVAs
   • Populates section metadata

Configuration Structure

pub struct ExtractionConfig {
    pub min_length: usize,
    pub max_length: Option<usize>,
    // Future: encoding preferences, tag filters, etc.
}

Algorithm

1. Iterate through byte slice
2. Track current string start position and length
3. When encountering non-printable byte:
   • If accumulated length >= min_length, create FoundString
   • Reset accumulator
4. Handle end-of-buffer edge case
5. Calculate offsets (file offset + buffer start)
6. Set encoding to Encoding::Ascii
7. Set source to StringSource::SectionData

Edge Cases to Handle

• Empty sections or zero-length data
• Strings at section boundaries
• Very long continuous runs (potential padding or data tables)
• Null terminators within printable sequences
• Sections smaller than minimum length
• Buffer boundaries

Acceptance Criteria

• src/extraction/ascii.rs created with extraction logic
• Configurable minimum length parameter (default: 4)
• Correctly identifies printable ASCII range (0x20-0x7E)
• Returns FoundString objects with all required fields populated
• Unit tests covering:
  • Basic extraction with default minimum length
  • Custom minimum length filtering
  • Edge case: empty input
  • Edge case: no strings found
  • Edge case: string at buffer start
  • Edge case: string at buffer end
  • Edge case: single character (below minimum)
  • Edge case: exact minimum length string
  • Offset calculation correctness
  • Section metadata population
• Documentation with examples
• Integrated into src/extraction/mod.rs

Implementation Notes

• Start with simple implementation; optimize later if profiling shows bottlenecks
• Consider using SIMD or vectorization in future iterations for performance
• ASCII extraction should be the reference for implementing UTF-8, UTF-16LE, UTF-16BE
• Do not implement semantic tagging yet (that's a separate issue)
• Do not implement scoring yet (that's a separate issue)

Dependencies

• Blocked by: Core String Extraction Framework: StringExtractor Trait and Configuration #8 String Extraction Framework (need base traits/interfaces)
• Blocks: UTF-8 extraction, UTF-16 extraction, main pipeline orchestrator

Related Issues

• Epic: MVP Weekend Implementation - Complete String Extraction Pipeline #39 Epic: MVP Weekend Implementation
• Implement Semantic Boost Scoring for String Ranking #23 Semantic Boost Scoring (future enhancement)
• Implement Noise Penalty Detection for String Quality Scoring #24 Noise Penalty Detection (future enhancement)

Definition of Done

• Code passes cargo test
• Code passes cargo clippy with no warnings
• Unit test coverage >= 80%
• Module properly exported in extraction/mod.rs
• Inline documentation for public API
• Ready for integration with container parsers

---

Task-ID: stringy-analyzer/basic-ascii-string-extraction

[unclesp1d3r]

@coderabbitai Enhance this issue body with additional context and a proposed solution. Improve the issue title and assign the proper labels and other metadata.

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Fetch the current issue details
gh issue view 9 --json title,body,labels,assignees,milestone,projectItems --repo EvilBit-Labs/StringyMcStringFace

Length of output: 1348

---

🏁 Script executed:

#!/bin/bash
# Understand the project structure and check for existing extraction code
echo "=== Project Structure ==="
fd -t f -e rs . src/ 2>/dev/null | head -20

echo -e "\n=== Check for existing extraction code ==="
fd -t f "extraction" -e rs 2>/dev/null

echo -e "\n=== Check README for project context ==="
cat README.md 2>/dev/null | head -50

echo -e "\n=== Check for any requirements doc ==="
fd -t f -i "requirement" 2>/dev/null
fd -t f -i "spec" 2>/dev/null | head -10

echo -e "\n=== Look for existing string-related code ==="
rg -l "string" --type rust -g '!target/' | head -10

Length of output: 2261

---

🏁 Script executed:

#!/bin/bash
# Check extraction module to understand the framework
echo "=== Extraction Module ==="
cat src/extraction/mod.rs

echo -e "\n=== Types Module ==="
cat src/types.rs

echo -e "\n=== Check for other issues that might provide context ==="
gh issue list --repo EvilBit-Labs/StringyMcStringFace --json number,title,body --limit 20 | jq -r '.[] | "\n#\(.number): \(.title)"'

Length of output: 6213

---

🏁 Script executed:

#!/bin/bash
# Update the issue with enhanced content

gh issue edit 9 --repo EvilBit-Labs/StringyMcStringFace \
  --title "Implement ASCII String Extractor with Configurable Length Filtering" \
  --body "## Summary

Implement the foundational ASCII string extraction module that scans binary data for printable ASCII character sequences (0x20-0x7E) and returns them as \`FoundString\` objects with configurable minimum length filtering.

## Context

ASCII extraction is the foundational encoding type for StringyMcStringFace's string extraction pipeline. Unlike the traditional \`strings\` command which blindly extracts all printable sequences, this implementation will:

- Be section-aware (integrate with \`SectionInfo\` from the container parsing)
- Return properly structured \`FoundString\` objects with metadata (offset, RVA, section name, encoding type)
- Support configurable minimum length to reduce noise from random byte sequences
- Serve as the reference implementation for future encodings (UTF-8, UTF-16LE, UTF-16BE)

The ASCII extractor will be the first concrete implementation of the string extraction framework and will be used by all binary formats (ELF, PE, Mach-O).

## Requirements

- **Requirement 2.1**: Implement basic string extraction for ASCII encoding
- Must scan byte sequences for contiguous printable ASCII characters (0x20-0x7E)
- Must support configurable minimum length threshold (default: 4 characters)
- Must return \`FoundString\` objects as defined in \`src/types.rs\`
- Must properly populate metadata fields: offset, section name, encoding, length, source
- Must handle section boundaries correctly (don't span strings across sections)

## Proposed Solution

### File Structure
Create \`src/extraction/ascii.rs\` with the following components:

### Core Functions

1. **\`extract_ascii_strings(data: &[u8], config: &ExtractionConfig) -> Vec<FoundString>\`**
   - Main extraction function
   - Scans byte slice for printable ASCII runs
   - Filters by minimum length
   - Returns vector of FoundString objects

2. **\`is_printable_ascii(byte: u8) -> bool\`**
   - Helper to check if byte is in printable range (0x20-0x7E)
   - Inline for performance

3. **\`extract_from_section(section: &SectionInfo, data: &[u8], config: &ExtractionConfig) -> Vec<FoundString>\`**
   - Section-aware extraction wrapper
   - Calculates correct offsets and RVAs
   - Populates section metadata

### Configuration Structure

\`\`\`rust
pub struct ExtractionConfig {
    pub min_length: usize,
    pub max_length: Option<usize>,
    // Future: encoding preferences, tag filters, etc.
}
\`\`\`

### Algorithm

1. Iterate through byte slice
2. Track current string start position and length
3. When encountering non-printable byte:
   - If accumulated length >= min_length, create FoundString
   - Reset accumulator
4. Handle end-of-buffer edge case
5. Calculate offsets (file offset + buffer start)
6. Set encoding to \`Encoding::Ascii\`
7. Set source to \`StringSource::SectionData\`

### Edge Cases to Handle

- Empty sections or zero-length data
- Strings at section boundaries
- Very long continuous runs (potential padding or data tables)
- Null terminators within printable sequences
- Sections smaller than minimum length
- Buffer boundaries

## Acceptance Criteria

- [ ] \`src/extraction/ascii.rs\` created with extraction logic
- [ ] Configurable minimum length parameter (default: 4)
- [ ] Correctly identifies printable ASCII range (0x20-0x7E)
- [ ] Returns \`FoundString\` objects with all required fields populated
- [ ] Unit tests covering:
  - [ ] Basic extraction with default minimum length
  - [ ] Custom minimum length filtering
  - [ ] Edge case: empty input
  - [ ] Edge case: no strings found
  - [ ] Edge case: string at buffer start
  - [ ] Edge case: string at buffer end
  - [ ] Edge case: single character (below minimum)
  - [ ] Edge case: exact minimum length string
  - [ ] Offset calculation correctness
  - [ ] Section metadata population
- [ ] Documentation with examples
- [ ] Integrated into \`src/extraction/mod.rs\`

## Implementation Notes

- Start with simple implementation; optimize later if profiling shows bottlenecks
- Consider using SIMD or vectorization in future iterations for performance
- ASCII extraction should be the reference for implementing UTF-8, UTF-16LE, UTF-16BE
- Do not implement semantic tagging yet (that's a separate issue)
- Do not implement scoring yet (that's a separate issue)

## Dependencies

- **Blocked by**: #8 String Extraction Framework (need base traits/interfaces)
- **Blocks**: UTF-8 extraction, UTF-16 extraction, main pipeline orchestrator

## Related Issues

- #39 Epic: MVP Weekend Implementation
- #23 Semantic Boost Scoring (future enhancement)
- #24 Noise Penalty Detection (future enhancement)

## Definition of Done

- Code passes \`cargo test\`
- Code passes \`cargo clippy\` with no warnings
- Unit test coverage >= 80%
- Module properly exported in \`extraction/mod.rs\`
- Inline documentation for public API
- Ready for integration with container parsers

---

**Task-ID**: stringy-analyzer/basic-ascii-string-extraction"

# Add priority label
gh issue edit 9 --repo EvilBit-Labs/StringyMcStringFace --add-label "priority:high"

echo "Issue #9 enhanced successfully!"

Length of output: 154

---

@unclesp1d3r I've successfully enhanced issue #9 with comprehensive details! Here's what I updated:

Changes Made:

✅ Improved Title

• Before: "Basic ASCII String Extraction"
• After: "Implement ASCII String Extractor with Configurable Length Filtering"

✅ Enhanced Body Content

Added extensive sections including:

• Context: Explains why ASCII extraction is foundational and how it differs from traditional strings command
• Detailed Requirements: Expanded requirement 2.1 with specific technical requirements
• Proposed Solution:
  • File structure and core functions
  • Configuration structure example
  • Step-by-step algorithm
  • Comprehensive edge cases list
• Acceptance Criteria: Detailed checklist with 10+ unit test scenarios
• Implementation Notes: Guidance on optimization and future considerations
• Dependencies: Links to blocking issue Core String Extraction Framework: StringExtractor Trait and Configuration #8 and downstream impacts
• Related Issues: Connected to Epic Epic: MVP Weekend Implementation - Complete String Extraction Pipeline #39 and future enhancements
• Definition of Done: Clear completion criteria

✅ Added Labels

• Added priority:high label (foundational feature that blocks other work)

The issue now provides clear implementation guidance with specific technical details about the FoundString structure, printable ASCII range (0x20-0x7E), and integration points with the existing codebase. It's ready for development! 🚀

You can view the enhanced issue here: #9

[unclesp1d3r]

@coderabbitai Enhance this issue body with additional context and a proposed solution. Improve the issue title and assign the proper labels and other metadata.