ci fixes on rustdoc

Author: marirs

Cargo.toml

@@ -18,7 +18,7 @@ license = "Apache-2.0"
 authors = ["Sriram <marirs@gmail.com>"]
 repository = "https://github.com/marirs/strix"
 description = "Extract obfuscated strings from binaries"
-keywords = ["malware", "strings", "deobfuscation", "reverse-engineering", "floss"]
+keywords = ["malware", "strings", "deobfuscation", "reverse-engineering", "binary-analysis"]
 categories = ["command-line-utilities", "parser-implementations"]
 
 [workspace.dependencies]

crates/strix-cli/src/main.rs

@@ -200,10 +200,9 @@ fn main() -> Result<()> {
 
 /// Render a human-readable grouped report.
 ///
-/// Sections appear in a fixed order matching FLOSS conventions:
-/// static, language, decoded, stack, tight. Empty sections are
-/// skipped. Within a section, strings are sorted by address (if
-/// known) else by file offset.
+/// Sections appear in a fixed order — static, language, decoded,
+/// stack, tight — with empty sections skipped. Within a section,
+/// strings are sorted by address (if known) else by file offset.
 fn print_human(result: &ExtractionResult<'_>, out: &mut dyn Write, quiet: bool) -> io::Result<()> {
     let groups = group_strings(&result.strings);
     let order = [

crates/strix-core/src/lib.rs

@@ -1,9 +1,5 @@
 //! Core types and JSON schema for the strix string-extraction library.
 //!
-//! The JSON output is designed to be compatible with `flare-floss`'s
-//! `--json` output where it makes sense, so consumers can swap one for
-//! the other.
-//!
 //! Lifetimes here are deliberate: every string-bearing struct carries
 //! a `'a` so that extractors that scan the input file directly
 //! (static, language) can borrow `&str` slices into the input bytes
@@ -25,8 +21,8 @@ pub use traits::Extractor;
 
 /// The kind of string that was extracted.
 ///
-/// This mirrors FLOSS's categories so the JSON output is intelligible to
-/// existing FLOSS tooling.
+/// String categories cover both raw printable runs (static / language)
+/// and bytes produced at runtime by decoders (stack / tight / decoded).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum StringKind {
@@ -143,15 +139,15 @@ impl<'a> ExtractedString<'a> {
 /// Options controlling extraction.
 #[derive(Debug, Clone)]
 pub struct ExtractOptions {
-    /// Minimum string length (in characters) for static strings. FLOSS
-    /// default is 4.
+    /// Minimum string length (in characters) for static strings.
+    /// Default is 4, matching the convention of classic `strings(1)`.
     pub min_length: usize,
     /// Which extractors to run. If `None`, run all available.
     pub enabled: Option<Vec<StringKind>>,
     /// Override file format detection. `None` = auto-detect.
     pub format_override: Option<FormatHint>,
     /// Hard upper bound on emulation work (per-function steps); applied
-    /// only by the emulation extractors. FLOSS default analog is ~20_000.
+    /// only by the emulation extractors. Reasonable default ~20_000.
     pub max_emulation_steps: u64,
     /// If true, drop duplicate strings from the result (matching on
     /// value + kind + encoding). The first occurrence is kept with its

crates/strix-emulator/src/analyzer.rs

@@ -1,8 +1,9 @@
-//! Code-flow analyzer built on [`iced_x86`].
+//! Code-flow analyzer built on `iced_x86`.
 //!
 //! Discovers functions, basic blocks, and call-graph edges in an
 //! executable. This is the analog of vivisect's analyzer in the
-//! original FLOSS Python code.
+//! intermediate code-flow representation the higher-level extractors
+//! consume.
 //!
 //! Two discovery strategies are combined:
 //!

crates/strix-emulator/src/driver.rs

@@ -20,8 +20,8 @@
 //! * **Snapshot/restore of `.data`/`.bss` between runs.** Writes to
 //!   the binary's writable sections leak across argument variations.
 //! * **Tight-string classification.** Stack writes inside a tight
-//!   inner loop are FLOSS's "tight strings", currently lumped in
-//!   with regular stack strings.
+//!   inner loop are categorized as "tight strings", currently
+//!   lumped in with regular stack strings.
 
 #![allow(missing_docs)]
 
@@ -426,7 +426,7 @@ impl EmulationDriver {
         self.run_function_with(entry, max_steps, &sets)
     }
 
-    /// Same as [`run_function_fuzzed`] but with caller-supplied arg
+    /// Same as [`Self::run_function_fuzzed`] but with caller-supplied arg
     /// sets. Useful for tests that want to exercise a specific shape.
     pub fn run_function_with(
         &mut self,

crates/strix-emulator/src/emulator.rs

@@ -4,9 +4,9 @@
 //! `unicorn-engine` links a C library and users who only want static
 //! or language-string extraction shouldn't have to pay for it.
 //!
-//! # What this gives FLOSS's algorithms
+//! # What this gives the higher-level extractors
 //!
-//! FLOSS's decoded/stack/tight extractors work by emulating candidate
+//! The decoded/stack/tight extractors work by emulating candidate
 //! functions and observing the bytes they write to memory. The
 //! primitives needed are:
 //!

crates/strix-emulator/src/heuristics.rs

@@ -1,6 +1,6 @@
 //! Heuristics for identifying candidate decoder routines.
 //!
-//! FLOSS's decoder identification looks at several signals per
+//! Decoder identification looks at several signals per
 //! function. We score each signal independently in `[0.0, 1.0]` and
 //! combine them with tunable weights into a final `score`.
 //!
@@ -18,8 +18,8 @@
 //! * **Caller count.** Decoders are typically called many times (each
 //!   string callsite). Functions with no callers are deprioritized.
 //!
-//! Default weights are an educated guess; tune against the FLOSS test
-//! corpus once we can run on real binaries.
+//! Default weights are an educated guess; tune against the
+//! decoder-fixture corpus once we can run on real binaries.
 
 use std::collections::BTreeMap;
 

crates/strix-emulator/src/lib.rs

@@ -54,7 +54,7 @@ pub struct EmulationResults<'a> {
 
 /// Minimum decoder score to bother emulating a candidate function.
 ///
-/// Tuned empirically against the FLOSS test fixtures: 0.3 catches the
+/// Tuned empirically against the decoder fixtures: 0.3 catches the
 /// borderline decoders in `test-decode-from-heap*` and the 64-bit
 /// `single-byte-xor` / `base64` / `substitution-cipher` fixtures
 /// without exploding emulation time on real binaries.

crates/strix-emulator/src/stack_strings.rs

@@ -10,12 +10,12 @@
 //! mov byte [rsp+3], 0
 //! ```
 //!
-//! FLOSS detects these via pattern analysis on the disassembly,
-//! independent of full CPU emulation. This module ports that
-//! approach. It runs entirely on iced-x86 — no Unicorn required —
-//! so it's available even when the `unicorn` feature is off, and
-//! it catches stack strings inside functions our brute-force
-//! emulator can't get into (faults early, indirect entry, etc.).
+//! We detect these via pattern analysis on the disassembly,
+//! independent of full CPU emulation. The matcher runs entirely on
+//! iced-x86 — no Unicorn required — so it's available even when the
+//! `unicorn` feature is off, and it catches stack strings inside
+//! functions our brute-force emulator can't get into (faults early,
+//! indirect entry, etc.).
 //!
 //! # Algorithm
 //!
@@ -37,8 +37,8 @@
 //!   stores is preserved — which is what matters for the printable
 //!   run.
 //! * **Register-relative stores.** `mov [rbp+N], imm` and stores via
-//!   other base registers are not recognized. FLOSS treats `rbp` the
-//!   same as `rsp`; adding that here is a one-line change.
+//!   other base registers are not recognized. Adding the standard
+//!   x86 base registers here is a localized one-line change.
 //! * **Multi-instruction patterns.** A common pattern is
 //!   `mov eax, 0x6c6c6548; mov [rsp], eax` (writes "Hell" via a
 //!   register). That requires tracking immediate-into-register

crates/strix-format/src/lib.rs

@@ -1,6 +1,6 @@
 //! Binary file-format parsing for strix.
 //!
-//! We use [`goblin`] to identify and parse PE, ELF, and Mach-O files,
+//! We use `goblin` to identify and parse PE, ELF, and Mach-O files,
 //! plus a passthrough for raw shellcode. The result is a unified
 //! [`ParsedInput`] structure describing the architecture, bitness,
 //! and a flat list of [`Section`]s that string extractors can use to