Trait Oracle

pub trait Oracle<A: Arch> {
    type MappableArea: MappableArea;

    const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool;

    // Required methods
    fn mappable_area(&self) -> Self::MappableArea;
    fn page_size(&mut self) -> u64;
    fn observe(
        &mut self,
        before: &SystemState<A>,
    ) -> Result<SystemState<A>, OracleError>;
    fn batch_observe_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>(
        &'a mut self,
        states: I,
    ) -> impl Iterator<Item = Observation<S, A>>;
    fn batch_observe_gpreg_only_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>(
        &'a mut self,
        states: I,
    ) -> impl Iterator<Item = Observation<S, A>>;
    fn scan_memory_accesses(
        &mut self,
        before: &SystemState<A>,
    ) -> Result<Vec<Addr>, OracleError>;
    fn debug_dump(&mut self);
    fn restart(&mut self);
    fn kill(self);

    // Provided methods
    fn random_mappable_page(&self, rng: &mut impl Rng) -> Page<A> { ... }
    fn observe_carefully(
        &mut self,
        before: &SystemState<A>,
    ) -> Result<SystemState<A>, OracleError> { ... }
    fn batch_observe<'a, const N: usize, S: AsSystemState<A> + 'a>(
        &mut self,
        states: [S; N],
    ) -> [Observation<S, A>; N] { ... }
}

An oracle that can observe instruction execution.

Required Associated Constants

const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool

Set to true if the instruction fetch errors are unreliable.

Required Associated Types

type MappableArea: MappableArea

The memory addresses that can be mapped by this oracle.

Required Methods

fn mappable_area(&self) -> Self::MappableArea

Returns the memory addresses that can be mapped by this oracle.

fn page_size(&mut self) -> u64

Returns the page size of the oracle.

fn observe( &mut self, before: &SystemState<A>, ) -> Result<SystemState<A>, OracleError>

Observes the output state after executing a single instruction in the before state.

fn batch_observe_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>( &'a mut self, states: I, ) -> impl Iterator<Item = Observation<S, A>>

Performs many observations in one go. Behaves idential to Self::observe, but is much more efficient.

fn batch_observe_gpreg_only_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>( &'a mut self, states: I, ) -> impl Iterator<Item = Observation<S, A>>

Performs many observations in one go. Only reads and writes the general-purpose registers. Other registers may have arbitrary values.

fn scan_memory_accesses( &mut self, before: &SystemState<A>, ) -> Result<Vec<Addr>, OracleError>

Uses debugging registers to determine all memory addresses accessed by the instruction. If this is not supported, returns an empty Vec.

fn debug_dump(&mut self)

Prints debugging information about the oracle.

fn restart(&mut self)

Restart the oracle, if possible.

fn kill(self)

Kills the oracle, if possible.

Provided Methods

fn random_mappable_page(&self, rng: &mut impl Rng) -> Page<A>

Returns a random mappable page.

fn observe_carefully( &mut self, before: &SystemState<A>, ) -> Result<SystemState<A>, OracleError>

Observes the output state after executing a single instruction in the before state. If possible, uses debugging registers to exhaustively check the exact memory locations that are accessed. Returns a memory access error if a memory is accessed that is not set in before.

Self::observe may not return the proper memory access error if a memory access occurs outside the areas mapped in before, but on the same page as a mapped area.

fn batch_observe<'a, const N: usize, S: AsSystemState<A> + 'a>( &mut self, states: [S; N], ) -> [Observation<S, A>; N]

Performs many observations in one go. Behaves idential to Self::observe, but is much more efficient.

Object Safety

This trait is not object safe.

Implementors

impl<'o, A: Arch, O: Oracle<A>> Oracle<A> for CarefulOracle<'o, A, O>

const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool = O::UNRELIABLE_INSTRUCTION_FETCH_ERRORS

type MappableArea = <O as Oracle<A>>::MappableArea

impl<A: Arch, O1: Oracle<A>, O2: Oracle<A>> Oracle<A> for VerifyOracle<A, O1, O2>

const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool = _

type MappableArea = DoubleCheckedMappableArea<<O1 as Oracle<A>>::MappableArea, <O2 as Oracle<A>>::MappableArea>

impl<A: Arch, O: Oracle<A>> Oracle<A> for InvocationCountingOracle<A, O>

const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool = O::UNRELIABLE_INSTRUCTION_FETCH_ERRORS

type MappableArea = <O as Oracle<A>>::MappableArea

impl<F, M> Oracle<FakeArch> for FakeOracle<F, M>

where F: Fn(&SystemState<FakeArch>) -> Result<SystemState<FakeArch>, OracleError>, M: Fn(&SystemState<FakeArch>) -> Result<Vec<Addr>, OracleError>,

const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool = false

type MappableArea = AnyArea