crackers 0.9.0

A tool for synthesizing Code Reuse Attacks (ROP chains) using Ghidra's p-code and Z3
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

use std::collections::HashSet;

use crate::synthesis::Decision;

#[derive(Debug, Clone)]
pub struct ConflictClause {
    decisions: Vec<Decision>,
    pub precondition: bool,
    pub postcondition: bool,
}

impl ConflictClause {
    pub fn combine(clauses: &[ConflictClause]) -> Self {
        let mut decisions = HashSet::new();
        let mut precondition = false;
        let mut postcondition = false;
        for x in clauses {
            for decision in &x.decisions {
                decisions.insert(*decision);
            }
            precondition |= x.precondition;
            postcondition |= x.postcondition;
        }
        Self {
            decisions: decisions.into_iter().collect(),
            precondition,
            postcondition,
        }
    }

    pub fn decisions(&self) -> &[Decision] {
        self.decisions.as_slice()
    }

    pub fn includes_index(&self, d: usize) -> bool {
        self.decisions.iter().any(|i| i.index == d)
    }
}

impl<'a, T: Iterator<Item = &'a Decision>> From<T> for ConflictClause {
    fn from(value: T) -> Self {
        Self {
            decisions: value.cloned().collect(),
            precondition: false,
            postcondition: false,
        }
    }
}
impl From<Decision> for ConflictClause {
    fn from(value: Decision) -> Self {
        Self {
            decisions: vec![value],
            precondition: false,
            postcondition: false,
        }
    }
}