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.
• 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);
    }
}

Reexports

pub use error::*;

Modules

analysis	Implementations and traits for static analysis over Falcon IL.
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.
translator	Translators for various architectures to Falcon IL.
types	Useful types used across multiple Falcon modules.