autarkie 0.8.0

autarkie - instant grammar fuzzing using 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

#[macro_export]
macro_rules! impl_converter {
    ($t:ty) => {
        #[derive(Debug, Clone)]
        pub struct FuzzDataTargetBytesConverter;

        impl FuzzDataTargetBytesConverter {
            pub fn new() -> Self {
                Self {}
            }
        }

        impl autarkie::ToTargetBytes<$t> for FuzzDataTargetBytesConverter {
            fn to_target_bytes<'a>(&mut self, input: &'a $t) -> autarkie::OwnedSlice<'a, u8> {
                let bytes = autarkie::serialize(input);
                let bytes = if bytes.len() == 0 {
                    vec![0, 0, 0, 0]
                } else {
                    bytes
                };
                autarkie::OwnedSlice::from(bytes)
            }
        }
    };
    // We may want to render to bytes manually (eg: to_string) so we offer the possibility of a closure too.
    ($t:ty, $closure:expr) => {
        #[derive(Debug, Clone)]
        pub struct FuzzDataTargetBytesConverter;

        impl FuzzDataTargetBytesConverter {
            pub fn new() -> Self {
                Self
            }
        }

        impl autarkie::ToTargetBytes<$t> for FuzzDataTargetBytesConverter {
            fn to_target_bytes<'a>(&mut self, input: &'a $t) -> autarkie::OwnedSlice<'a, u8> {
                let bytes = $closure(input);
                let bytes = if bytes.len() == 0 {
                    vec![0, 0, 0, 0]
                } else {
                    bytes
                };
                autarkie::OwnedSlice::from(bytes)
            }
        }
    };
}

#[macro_export]
macro_rules! impl_input {
    ($t:ty) => {
        impl autarkie::Input for $t {
            fn to_file<P>(&self, path: P) -> Result<(), autarkie::LibAFLError>
            where
                P: AsRef<std::path::Path>,
            {
                let bytes = autarkie::serialize(self);
                std::fs::write(path, bytes)?;
                Ok(())
            }

            // TODO: don't serialize here
            fn generate_name(&self, id: Option<autarkie::CorpusId>) -> String {
                let bytes = autarkie::serialize(self);
                std::format!("{}", autarkie::hash(bytes.as_slice()))
            }

            fn from_file<P>(path: P) -> Result<Self, autarkie::LibAFLError>
            where
                P: AsRef<std::path::Path>,
            {
                let data = std::fs::read(path)?;
                let res = autarkie::deserialize::<$t>(&mut data.as_slice());
                Ok(res)
            }
        }
    };
}

#[macro_export]
macro_rules! fuzz_afl_inner {
    ($t: ty) => {
        fn main() {
            let harness: Option<fn(&$t) -> autarkie::LibAFLExitKind> = None;
            $crate::fuzzer::run_fuzzer(FuzzDataTargetBytesConverter::new(), harness);
        }
    };
}

#[macro_export]
macro_rules! fuzz_afl {
    ($t:ty) => {
        $crate::impl_input!($t);
        $crate::impl_converter!($t);
        $crate::fuzz_afl_inner!($t);
        $crate::impl_hash!($t);
    };
    ($t:ty, $closure:expr) => {
        $crate::impl_input!($t);
        $crate::impl_converter!($t, $closure);
        $crate::fuzz_afl_inner!($t);
        $crate::impl_hash!($t);
    };
}

#[macro_export]
macro_rules! impl_hash {
    ($t:ty) => {
        impl std::hash::Hash for $t {
            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
                autarkie::serialize(&self).hash(state)
            }
        }
    };
}