rebg 0.1.0

rebg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use rebg::analyzer::dump::TraceDumper;
use rebg::analyzer::Analyzer;
use rebg::host::docker::{Docker, DockerArgs};
use rebg::host::native::{Native, NativeArgs};
use rebg::state::{Aarch64Step, Step, X64Step};
use rebg::tracer::qemu::QEMUParser;
use rebg::tracer::TracerCmd;
use rebg::{
    arch::Arch,
    host::Host,
    tracer::{qemu::QEMU, Tracer},
};
use std::fmt;
use std::path::Path;
use std::{fs, path::PathBuf};

#[derive(argh::FromArgs)]
/// tracer
struct Arguments {
    /// the program to trace
    #[argh(positional)]
    program: PathBuf,

    #[argh(option, short = 'a')]
    /// override detected architecture (arm64, amd64, ...)
    target_arch: Option<Arch>,

    #[argh(subcommand)]
    launcher: LauncherArgs,
}

#[derive(argh::FromArgs)]
#[argh(subcommand)]
enum LauncherArgs {
    Docker(DockerArgs),
    Native(NativeArgs),
}

impl LauncherArgs {
    fn start_tracer(self, program: PathBuf, arch: Arch) -> Launchers {
        match self {
            LauncherArgs::Docker(x) => Launchers::Docker(x.start(program, arch)),
            LauncherArgs::Native(x) => Launchers::Native(x.start()),
        }
    }
}

enum Launchers {
    Docker(Docker),
    Native(Native),
}

impl Host for Launchers {
    type Error = anyhow::Error;

    fn launch(
        &self,
        program: String,
        args: Vec<String>,
    ) -> Result<std::process::Child, Self::Error> {
        match self {
            Launchers::Docker(d) => d.launch(program, args),
            Launchers::Native(n) => n.launch(program, args),
        }
    }

    fn read_file(&self, path: &std::path::Path) -> Result<Vec<u8>, Self::Error> {
        match self {
            Launchers::Docker(x) => x.read_file(path),
            Launchers::Native(x) => x.read_file(path),
        }
    }
}

fn main() {
    let Arguments {
        program,
        target_arch,
        launcher,
    } = argh::from_env();

    let buffer = fs::read(&program).unwrap();
    let elf = goblin::elf::Elf::parse(&buffer).unwrap();
    let target_arch = target_arch.unwrap_or_else(|| Arch::from_elf(elf.header.e_machine).unwrap());

    let qemu = QEMU {};

    let launcher = launcher.start_tracer(program.clone(), target_arch);

    match target_arch {
        Arch::ARM64 => {
            let parser =
                launch_qemu::<_, _, Aarch64Step, 32>(&launcher, qemu, target_arch, &program);
            TraceDumper::analyze::<_, _, QEMU, _, 32>(&launcher, parser, target_arch);
        }
        Arch::X86_64 => {
            let parser = launch_qemu::<_, _, X64Step, 16>(&launcher, qemu, target_arch, &program);
            TraceDumper::analyze::<_, _, QEMU, _, 16>(&launcher, parser, target_arch);
        }
    }
}

fn launch_qemu<LAUNCHER, TRACER, STEP, const N: usize>(
    launcher: &LAUNCHER,
    tracer: TRACER,
    arch: Arch,
    program: &Path,
) -> QEMUParser<STEP, N>
where
    LAUNCHER: Host<Error = anyhow::Error>,
    TRACER: Tracer<STEP, N, ITER = QEMUParser<STEP, N>>,
    STEP: Step<N> + Send + 'static + fmt::Debug,
    STEP: for<'a> TryFrom<&'a [String], Error = anyhow::Error>,
{
    let cmd: TracerCmd<STEP, N> = tracer.command(program, arch);

    let child = launcher.launch(cmd.program, cmd.args).unwrap();

    tracer.parse(child)
}