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

Modules

analysis

Implementations and traits for static analysis over Falcon IL.

architecture

Information and types for Falcon’s supported architectures.

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.

Enums

Error

Type Aliases

RC