falcon 0.6.0

A Binary Analysis Framework in Rust
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Experimental loader which takes a program specification in Json form.

use crate::architecture::*;
use crate::loader::*;
use crate::memory::backing::*;
use crate::memory::MemoryPermissions;
use crate::Error;
use base64::Engine;
use serde_json::Value;
use std::fs::File;
use std::io::Read;
use std::path::Path;

/// Experimental loader which takes a program specification in Json form.
///
/// See the binary ninja script for an example use.
#[derive(Debug)]
pub struct Json {
    function_entries: Vec<FunctionEntry>,
    memory: Memory,
    architecture: Box<dyn Architecture>,
    entry: u64,
}

impl Json {
    /// Create a new `Json` loader from the given file.
    pub fn from_file(filename: &Path) -> Result<Json, Error> {
        let mut file = File::open(filename)?;
        let mut buf = Vec::new();
        file.read_to_end(&mut buf)?;

        let root: Value = serde_json::from_str(&String::from_utf8(buf)?)?;

        let architecture = match root["arch"] {
            Value::String(ref architecture) => {
                if architecture == "x86" {
                    Box::new(X86::new())
                } else {
                    return Err(Error::UnsupprotedArchitecture);
                }
            }
            _ => return Err(Error::UnsupprotedArchitecture),
        };

        let entry = match root["entry"] {
            Value::Number(ref number) => number.as_u64().unwrap(),
            _ => return Err(Error::FalconInternal("entry missing".to_string())),
        };

        let mut function_entries = Vec::new();
        if let Value::Array(ref functions) = root["functions"] {
            for function in functions {
                let address = match function["address"] {
                    Value::Number(ref address) => match address.as_u64() {
                        Some(address) => address,
                        None => {
                            return Err(Error::FalconInternal(
                                "function address not u64".to_string(),
                            ))
                        }
                    },
                    _ => {
                        return Err(Error::FalconInternal(
                            "address missing for function".to_string(),
                        ))
                    }
                };

                let name = match function["name"] {
                    Value::String(ref name) => name.to_string(),
                    _ => {
                        return Err(Error::FalconInternal(
                            "name missing for function".to_string(),
                        ))
                    }
                };

                function_entries.push(FunctionEntry::new(address, Some(name)));
            }
        } else {
            return Err(Error::FalconInternal("functions missing".to_string()));
        }

        let mut memory = Memory::new(architecture.endian());
        if let Value::Array(ref segments) = root["segments"] {
            for segment in segments {
                let address = match segment["address"] {
                    Value::Number(ref address) => match address.as_u64() {
                        Some(address) => address,
                        None => {
                            return Err(Error::FalconInternal(
                                "segment address not u64".to_string(),
                            ))
                        }
                    },
                    _ => {
                        return Err(Error::FalconInternal(
                            "address missing for segment".to_string(),
                        ))
                    }
                };

                let bytes = match segment["bytes"] {
                    Value::String(ref bytes) => {
                        base64::engine::general_purpose::STANDARD_NO_PAD.decode(bytes)?
                    }
                    _ => {
                        return Err(Error::FalconInternal(
                            "bytes missing for segment".to_string(),
                        ))
                    }
                };

                memory.set_memory(address, bytes, MemoryPermissions::ALL);
            }
        } else {
            return Err(Error::FalconInternal("segments missing".to_string()));
        }

        Ok(Json {
            function_entries,
            memory,
            architecture,
            entry,
        })
    }
}

impl Loader for Json {
    fn memory(&self) -> Result<Memory, Error> {
        Ok(self.memory.clone())
    }

    fn function_entries(&self) -> Result<Vec<FunctionEntry>, Error> {
        Ok(self.function_entries.clone())
    }

    fn program_entry(&self) -> u64 {
        self.entry
    }

    fn architecture(&self) -> &dyn Architecture {
        self.architecture.as_ref()
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn symbols(&self) -> Vec<Symbol> {
        Vec::new()
    }
}