Struct Panda 

pub struct Panda { /* private fields */ }

Builder for creating PANDA instances. Only for use in libpanda mode.

Implementations

impl Panda

pub fn new() -> Self

Create a new PANDA instance.

Example

Panda::new()
    .generic("x86_64")
    .run();

Examples found in repository

examples/hooks.rs (line 33)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/osi.rs (line 44)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/guest_ptr.rs (line 47)

fn main() {
    Panda::new().arch(panda::Arch::x86_64).configurable().run();
}

examples/unicorn_taint.rs (line 78)

fn main() {
    Panda::new()
        .arch(panda::Arch::x86_64)
        .configurable()
        .run();
}

examples/syscall_injection.rs (line 33)

fn main() {
    Panda::new()
        .generic("x86_64")
        //.args(&["-loadvm", "root"])
        .run();
}

examples/ppp_callback_export.rs (line 27)

fn main() {
    let mut i = 0;
    let callback = panda::Callback::new();
    callback.before_block_exec(move |cpu, _| {
        if i % 2 == 0 {
            on_every_even_block::trigger(cpu);
        } else {
            if on_every_odd_block::trigger(cpu) {
                callback.disable();
            }
        }
        i += 1;
    });

    on_every_even_block::add_callback(on_even_test);
    on_every_odd_block::add_callback(on_odd_test);

    Panda::new().generic("x86_64").replay("test").run();
}

Additional examples can be found in:

• examples/closures.rs

pub fn arg<S: Into<String>>(&mut self, arg: S) -> &mut Self

Add an argument for PANDA

Example

Panda::new()
    .arg("-nomonitor")
    .run();

pub fn args<I, S>(&mut self, args: I) -> &mut Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Add a set of extra arguments for PANDA

Example

Panda::new()
    .args(&["-panda", "callstack_instr"])
    .run();

pub fn arch(&mut self, arch: Arch) -> &mut Self

Sets the architecture of the guest

Example

Panda::new()
    .arch(Arch::i386)
    .run();

Examples found in repository

examples/guest_ptr.rs (line 47)

fn main() {
    Panda::new().arch(panda::Arch::x86_64).configurable().run();
}

examples/unicorn_taint.rs (line 79)

fn main() {
    Panda::new()
        .arch(panda::Arch::x86_64)
        .configurable()
        .run();
}

pub fn configurable(&mut self) -> &mut Self

Set the machine to PANDA’s configurable machine

Example

Panda::new()
    .configurable()
    .run();

Examples found in repository

examples/guest_ptr.rs (line 47)

fn main() {
    Panda::new().arch(panda::Arch::x86_64).configurable().run();
}

examples/unicorn_taint.rs (line 80)

fn main() {
    Panda::new()
        .arch(panda::Arch::x86_64)
        .configurable()
        .run();
}

pub fn enable_graphics(&mut self) -> &mut Self

Example

Panda::new()
    .enable_graphics()
    .run();

pub fn expect_prompt<S: Into<String>>(&mut self, prompt_regex: S) -> &mut Self

Regular expression describing the prompt exposed by the guest on a serial console. Used in order to know when running a command has finished with its output.

pub fn mem<S: Into<String>>(&mut self, mem: S) -> &mut Self

Set the available memory. If restoring from a snapshot or viewing a replay, this must be the same as when the replay/snapshot was taken.

pub fn generic<S: Into<String>>(&mut self, generic: S) -> &mut Self

Use generic PANDA Qcow for run

Example

Panda::new()
    .generic("x86_64")
    .run();

Examples found in repository

examples/hooks.rs (line 33)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/osi.rs (line 44)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/syscall_injection.rs (line 34)

fn main() {
    Panda::new()
        .generic("x86_64")
        //.args(&["-loadvm", "root"])
        .run();
}

examples/ppp_callback_export.rs (line 27)

fn main() {
    let mut i = 0;
    let callback = panda::Callback::new();
    callback.before_block_exec(move |cpu, _| {
        if i % 2 == 0 {
            on_every_even_block::trigger(cpu);
        } else {
            if on_every_odd_block::trigger(cpu) {
                callback.disable();
            }
        }
        i += 1;
    });

    on_every_even_block::add_callback(on_even_test);
    on_every_odd_block::add_callback(on_odd_test);

    Panda::new().generic("x86_64").replay("test").run();
}

examples/closures.rs (line 26)

fn main() {
    // Callbacks can capture state
    let mut count = 1;
    let bb_callback = Callback::new();
    bb_callback.before_block_exec(move |cpu, _| {
        println!("Block: {} | PC: {:#x?}", count, panda::regs::get_pc(cpu));
        count += 1;
        if count > 5 {
            // callbacks can disable themselves by capturing a copy
            // of the `Callback` reference to it
            bb_callback.disable();
        }
    });

    // If you don't need to enable and disable the callback, you can just
    // use method chaining instead of assigning to a variable
    PppCallback::new().on_rec_auxv(|_, _, auxv| {
        // print out the auxillary vector when any process starts
        dbg!(auxv);
    });

    Panda::new().generic("x86_64").replay("test").run();
}

pub fn replay<S: Into<String>>(&mut self, replay: S) -> &mut Self

Run the given replay in the PANDA instance. Equivalent to -replay [name] from the PANDA command line.

Example

Panda::new()
    .replay("grep_recording")
    .run();

Examples found in repository

examples/hooks.rs (line 33)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/osi.rs (line 44)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/ppp_callback_export.rs (line 27)

fn main() {
    let mut i = 0;
    let callback = panda::Callback::new();
    callback.before_block_exec(move |cpu, _| {
        if i % 2 == 0 {
            on_every_even_block::trigger(cpu);
        } else {
            if on_every_odd_block::trigger(cpu) {
                callback.disable();
            }
        }
        i += 1;
    });

    on_every_even_block::add_callback(on_even_test);
    on_every_odd_block::add_callback(on_odd_test);

    Panda::new().generic("x86_64").replay("test").run();
}

examples/closures.rs (line 26)

fn main() {
    // Callbacks can capture state
    let mut count = 1;
    let bb_callback = Callback::new();
    bb_callback.before_block_exec(move |cpu, _| {
        println!("Block: {} | PC: {:#x?}", count, panda::regs::get_pc(cpu));
        count += 1;
        if count > 5 {
            // callbacks can disable themselves by capturing a copy
            // of the `Callback` reference to it
            bb_callback.disable();
        }
    });

    // If you don't need to enable and disable the callback, you can just
    // use method chaining instead of assigning to a variable
    PppCallback::new().on_rec_auxv(|_, _, auxv| {
        // print out the auxillary vector when any process starts
        dbg!(auxv);
    });

    Panda::new().generic("x86_64").replay("test").run();
}

pub fn plugin_args<T: PandaArgs>(&mut self, args: &T) -> &mut Self

Load a plugin with args provided by a PandaArgs struct.

Example

use panda::prelude::*;

#[derive(PandaArgs)]
#[name = "stringsearch"]
struct StringSearch {
    str: String
}

fn main() {
    Panda::new()
        .generic("x86_64")
        .replay("test")
        .plugin_args(&StringSearch {
            str: "test".into()
        })
        .run();
}

pub fn run(&mut self)

Start the PANDA instance with the given settings. This is a blocking operation.

Example

Panda::new()
    .generic("x86_64")
    .run();

Examples found in repository

examples/hooks.rs (line 33)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/osi.rs (line 44)

fn main() {
    Panda::new().generic("x86_64").replay("test").run();
}

examples/guest_ptr.rs (line 47)

fn main() {
    Panda::new().arch(panda::Arch::x86_64).configurable().run();
}

examples/unicorn_taint.rs (line 81)

fn main() {
    Panda::new()
        .arch(panda::Arch::x86_64)
        .configurable()
        .run();
}

examples/syscall_injection.rs (line 36)

fn main() {
    Panda::new()
        .generic("x86_64")
        //.args(&["-loadvm", "root"])
        .run();
}

examples/ppp_callback_export.rs (line 27)

fn main() {
    let mut i = 0;
    let callback = panda::Callback::new();
    callback.before_block_exec(move |cpu, _| {
        if i % 2 == 0 {
            on_every_even_block::trigger(cpu);
        } else {
            if on_every_odd_block::trigger(cpu) {
                callback.disable();
            }
        }
        i += 1;
    });

    on_every_even_block::add_callback(on_even_test);
    on_every_odd_block::add_callback(on_odd_test);

    Panda::new().generic("x86_64").replay("test").run();
}

Additional examples can be found in:

• examples/closures.rs

pub fn run_after_init(func: impl FnOnce() + Send + Sync + 'static)

Queue up a function that should run before libpanda has started but after the libpanda has been initialized. If run under a plugin context (e.g. no libpanda), or libpanda is currently running, then the function will run immediately.

This is useful for functions that may require waiting until things like arguments or OS has been set, such as setting up an OSI callback.

Trait Implementations

impl Default for Panda

fn default() -> Panda

Returns the “default value” for a type.