Crate falcon

Falcon: A Binary Analysis Framework in Rust.

Falcon is a framework in rust for implementing formal analyses over binary programs. A quick synopsis of Falcon's modules:

• analysis - A fixed-point engine and methods for abstract interpretation over Falcon IL. Example, usable analyses are given.
• architecture - Information on Falcon's supported architectures.
• executor - A concrete execution engine over Falcon IL.
• graph - A simple directed graph library.
• il - Falcon's Intermediate Language.
• loader - Loaders for binary formats, currently supporting Elf.
• memory - A layered memory model over generic types.
• translator - Translators from native architectures to Falcon IL.

Falcon also has bindings for the scripting language gluon, which makes exploratory analysis over Falcon quick and pleasant.

use falcon::loader::Elf;
use falcon::loader::Loader;
use std::path::Path;

let elf = Elf::from_file(Path::new("test_binaries/simple-0/simple-0"))?;
for function in elf.program()?.functions() {
    for block in function.blocks() {
        println!("Block {} in Function {:x}", block.index(), function.address());
        println!("{}", block);
    }
}

Re-exports

pub use error::*;

Modules

analysis	Implementations and traits for static analysis over Falcon IL.
architecture	Information and types for Falcon's supported architectures.
error	Falcon Error types.
executor	Concrete execution over Falcon IL.
graph	Implements a directed graph.
il	Falcon Intermediate Language.
loader	Loading executable binaries into Falcon.
memory	Efficient memory representations.
transformation	Implementations and traits for code transformation over Falcon IL.
translator	Translators for various architectures to Falcon IL.

Type Definitions

RC