Struct memflex::Pattern

pub struct Pattern<const N: usize>(/* private fields */);

Represents a staticly built sequence of bytes to match against.

let data = b"\x11\x22\x33";
let ida = ida_pat!("11 ? 33");
let peid = peid_pat!("11 ?? 33");
let code = code_pat!(b"\x11\x00\x33", "x?x");
assert!(ida.matches(data) && peid.matches(data) && code.matches(data));

Implementations

impl<const N: usize> Pattern<N>

pub fn to_ida_style(&self) -> String

Converts pattern to IDA style string.

pub fn to_peid_style(&self) -> String

Converts pattern to PEID style string.

pub fn to_code_style(&self) -> (String, String)

Converts pattern to code style string, returing pattern and mask.

pub const fn matches(&self, data: &[u8]) -> bool

Checks if pattern matches byte slice.

let data = b"\x11\x22\x33";
let pat = ida_pat!("11 ? 33");
assert!(pat.matches(data));

pub const fn from_ida_style(pat: &'static str) -> Pattern<N>

Creates pattern from IDA style string.

// Pattern parsing is a contant call and happens at compile time.
let ida = ida_pat!("13 ? D1");
let data = b"\x13\x01\xD1";
assert!(ida.matches(data));

pub const fn from_peid_style(pat: &'static str) -> Pattern<N>

Creates pattern from PEID style string.

// Pattern parsing is a contant call and happens at compile time.
let peid = peid_pat!("13 ?? D1");
let data = b"\x13\x01\xD1";
assert!(peid.matches(data));

pub const fn from_code_style( pat: &'static [u8], mask: &'static str ) -> Pattern<N>

Creates pattern from code style strings.

let pat = code_pat!(b"\x11\x55\xE2", "x?x");
let data = b"\x11\x01\xE2";
assert!(pat.matches(data));

Trait Implementations

impl<const N: usize> Clone for Pattern<N>

fn clone(&self) -> Pattern<N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for Pattern<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Hash for Pattern<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> Matcher for Pattern<N>

fn matches(&self, seq: &[u8]) -> bool

Matches byte sequence agains the pattern

fn len(&self) -> usize

Size of the pattern

impl<const N: usize> PartialEq<Pattern<N>> for Pattern<N>

fn eq(&self, other: &Pattern<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Copy for Pattern<N>

impl<const N: usize> Eq for Pattern<N>

impl<const N: usize> StructuralEq for Pattern<N>

impl<const N: usize> StructuralPartialEq for Pattern<N>