feat: allowing the match target to suggest a match hint to no longer require the whole length being exposed via the subrange

Author: WolverinDEV

bmatcher-core/src/matcher.rs

@@ -9,7 +9,7 @@ use crate::{
 };
 
 /// Hinting where the pattern might be matching the target
-enum MatchHint {
+pub enum MatchHint {
     /// A match hint could not be generated
     Unsupported,
 
@@ -316,33 +316,8 @@ impl<'a, S: Stack<u32>, C: Stack<usize>> BinaryMatcher<'a, S, C> {
             return MatchHint::Unsupported;
         }
 
-        let Some(target_buffer) = self
-            .target
-            .subrange(self.current_offset, self.match_length - self.current_offset)
-        else {
-            /* memory is not continuous */
-            return MatchHint::Unsupported;
-        };
-
-        Self::fuzzy_search(&fs_buffer[0..fs_buffer_len], target_buffer)
-            .map_or(MatchHint::NoMatches, |offset| {
-                MatchHint::MaybeMatch(self.current_offset + offset)
-            })
-    }
-
-    fn fuzzy_search(needle: &[u8], haystack: &[u8]) -> Option<usize> {
-        for offset in 0..(haystack.len() - needle.len()) {
-            let is_match = needle
-                .iter()
-                .zip(&haystack[offset..offset + needle.len()])
-                .all(|(a, b)| *a == *b);
-
-            if is_match {
-                return Some(offset);
-            }
-        }
-
-        None
+        self.target
+            .match_hint(self.current_offset, &fs_buffer[0..fs_buffer_len])
     }
 
     fn next_match_looped(&mut self) -> Option<&[u32]> {

bmatcher-core/src/target.rs

@@ -1,3 +1,5 @@
+use crate::matcher::MatchHint;
+
 /// A trait for targets that can be matched against a binary pattern.
 ///
 /// Implementing this trait allows matching against data sources that may not be
@@ -9,6 +11,10 @@ pub trait MatchTarget {
     /// Returns the total length of the data which will be scaned when matching a binary pattern.
     fn match_length(&self) -> usize;
 
+    /// Return a match hint based of the given `byte_sequence` which will be used to evaluate
+    /// the full pattern at that offset.
+    fn match_hint(&self, offset: usize, byte_sequence: &[u8]) -> MatchHint;
+
     /// Retrieves a subrange of the data, starting at the specified offset and spanning the given number of bytes.
     ///
     /// # Parameters
@@ -34,6 +40,25 @@ impl MatchTarget for &[u8] {
         self.len()
     }
 
+    fn match_hint(&self, offset: usize, byte_sequence: &[u8]) -> MatchHint {
+        if offset + byte_sequence.len() >= self.len() {
+            return MatchHint::NoMatches;
+        }
+
+        for offset in offset..(self.len() - byte_sequence.len()) {
+            let is_match = byte_sequence
+                .iter()
+                .zip(&self[offset..offset + byte_sequence.len()])
+                .all(|(a, b)| *a == *b);
+
+            if is_match {
+                return MatchHint::MaybeMatch(offset);
+            }
+        }
+
+        MatchHint::NoMatches
+    }
+
     fn subrange(&self, offset: usize, byte_count: usize) -> Option<&[u8]> {
         if offset + byte_count > self.len() {
             return None;