chore: update jingle APIs (#72)

* Update APIs

* fmt

* clippy

Author: toolCHAINZ

crackers/Cargo.toml

@@ -24,7 +24,7 @@ toml = ["dep:toml_edit"]
 z3-gh-release = ["z3/gh-release"]
 
 [dependencies]
-jingle = { version = "0.2.6", features = ["gimli"] }
+jingle = { version = "0.3.0", features = ["gimli"] }
 z3 = "0.18.2"
 serde = { version = "1.0.203", features = ["derive"] }
 thiserror = "2.0"

crackers/src/config/constraint.rs

@@ -1,11 +1,12 @@
 use crate::error::CrackersError;
 use crate::synthesis::builder::{StateConstraintGenerator, TransitionConstraintGenerator};
 use jingle::modeling::{ModeledBlock, ModelingContext, State};
-use jingle::sleigh::{ArchInfoProvider, VarNode};
+use jingle::sleigh::{SleighArchInfo, VarNode};
 use jingle::varnode::{ResolvedIndirectVarNode, ResolvedVarnode};
 #[cfg(feature = "pyo3")]
 use pyo3::pyclass;
 use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
 use std::collections::HashMap;
 use std::ops::Add;
 use std::sync::Arc;
@@ -21,22 +22,23 @@ pub struct ConstraintConfig {
 }
 
 impl ConstraintConfig {
-    pub fn get_preconditions<'a, T: ArchInfoProvider>(
-        &'a self,
-        sleigh: &'a T,
-    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> + 'a {
+    pub fn get_preconditions<T: Borrow<SleighArchInfo>>(
+        &self,
+        sleigh: T,
+    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> {
+        let sleigh = sleigh.borrow().clone();
         self.precondition
             .iter()
-            .flat_map(|c| c.constraints(sleigh, self.pointer.clone()))
+            .flat_map(move |c| c.constraints(sleigh.clone(), self.pointer.clone()))
     }
 
-    pub fn get_postconditions<'a, T: ArchInfoProvider>(
-        &'a self,
-        sleigh: &'a T,
-    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> + 'a {
+    pub fn get_postconditions<T: Borrow<SleighArchInfo>>(
+        &self,
+        sleigh: T,
+    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> {
         self.postcondition
             .iter()
-            .flat_map(|c| c.constraints(sleigh, self.pointer.clone()))
+            .flat_map(move |c| c.constraints(sleigh.borrow().clone(), self.pointer.clone()))
     }
 
     pub fn get_pointer_constraints(
@@ -55,14 +57,17 @@ pub struct StateEqualityConstraint {
 }
 
 impl StateEqualityConstraint {
-    pub fn constraints<'a, T: ArchInfoProvider>(
-        &'a self,
-        sleigh: &'a T,
+    pub fn constraints<T: Borrow<SleighArchInfo>>(
+        &self,
+        info: T,
         c: Option<PointerRangeConstraints>,
-    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> + 'a {
-        let register_iterator = self.register.iter().flat_map(|map| {
-            map.iter().filter_map(|(name, value)| {
-                if let Some(vn) = sleigh.get_register(name) {
+    ) -> impl Iterator<Item = Arc<StateConstraintGenerator>> {
+        let info = info.borrow().clone();
+        let info2 = info.clone();
+        let register_iterator = self.register.iter().flat_map(move |map| {
+            let info = info.clone();
+            map.iter().filter_map(move |(name, value)| {
+                if let Some(vn) = info.register(name) {
                     Some(Arc::new(gen_register_constraint(vn.clone(), *value as u64))
                         as Arc<StateConstraintGenerator>)
                 } else {
@@ -75,10 +80,12 @@ impl StateEqualityConstraint {
             .memory
             .iter()
             .map(|c| Arc::new(gen_memory_constraint(c.clone())) as Arc<StateConstraintGenerator>);
+        let info = info2;
         let pointer_iterator = self.pointer.iter().flat_map(move |map| {
             let c1 = c.clone();
+            let info = info.clone();
             map.iter().filter_map(move |(name, value)| {
-                if let Some(vn) = sleigh.get_register(name) {
+                if let Some(vn) = info.register(name) {
                     Some(Arc::new(gen_register_pointer_constraint(
                         vn.clone(),
                         value.clone(),
@@ -129,7 +136,12 @@ pub fn gen_memory_constraint(
     m: MemoryEqualityConstraint,
 ) -> impl Fn(&State, u64) -> Result<Bool, CrackersError> + Send + Sync + Clone + 'static {
     move |state, _addr| {
-        let data = state.read_varnode(&state.varnode(&m.space, m.address, m.size).unwrap())?;
+        let data = state.read_varnode(
+            &state
+                .arch_info()
+                .varnode(&m.space, m.address, m.size)
+                .unwrap(),
+        )?;
         let constraint = data.eq(BV::from_u64(m.value as u64, data.get_size()));
         Ok(constraint)
     }
@@ -166,15 +178,15 @@ pub fn gen_register_pointer_constraint(
                 pointer_location: vn.clone(),
                 pointer: pointer.clone().add(i as u64),
                 access_size_bytes: 1,
-                pointer_space_idx: state.get_code_space_idx(),
+                pointer_space_idx: state.get_default_code_space_info().index,
             });
             let actual = state.read_resolved(&char_ptr)?;
             bools.push(actual.eq(&expected))
         }
         let pointer = state.read_varnode(&vn)?;
         let resolved = ResolvedVarnode::Indirect(ResolvedIndirectVarNode {
             pointer_location: vn.clone(),
-            pointer_space_idx: state.get_code_space_idx(),
+            pointer_space_idx: state.get_default_code_space_info().index,
             access_size_bytes: value.len(),
             pointer,
         });
@@ -199,7 +211,8 @@ pub fn gen_pointer_range_state_invariant(
         match vn {
             ResolvedVarnode::Direct(d) => {
                 // todo: this is gross
-                let should_constrain = state.get_code_space_idx() == d.space_index;
+                let should_constrain =
+                    state.arch_info().default_code_space_index() == d.space_index;
                 match should_constrain {
                     false => Ok(None),
                     true => {

crackers/src/config/mod.rs

@@ -37,8 +37,8 @@ impl CrackersConfig {
         let library = self.library.build(&self.sleigh)?;
         let mut b = SynthesisParamsBuilder::default();
         if let Some(c) = &self.constraint {
-            b.preconditions(c.get_preconditions(&library).collect());
-            b.postconditions(c.get_postconditions(&library).collect());
+            b.preconditions(c.get_preconditions(&library.arch_info()).collect());
+            b.postconditions(c.get_postconditions(&library.arch_info()).collect());
             b.pointer_invariants(c.get_pointer_constraints().collect());
         }
         b.gadget_library(library)

crackers/src/gadget/another_iterator.rs

@@ -1,6 +1,6 @@
-use jingle::JingleContext;
 use jingle::modeling::{ModeledInstruction, ModelingContext};
-use jingle::sleigh::{Instruction, OpCode};
+use jingle::sleigh::{Instruction, OpCode, SleighArchInfo};
+use std::borrow::Borrow;
 use tracing::trace;
 use z3::Solver;
 use z3::ast::Ast;
@@ -12,7 +12,7 @@ pub struct TraceCandidateIterator<'a, T>
 where
     T: Iterator<Item = &'a Gadget>,
 {
-    jingle: JingleContext,
+    info: SleighArchInfo,
     _solver: Solver,
     gadgets: T,
     trace: Vec<ModeledInstruction>,
@@ -22,10 +22,14 @@ impl<'a, T> TraceCandidateIterator<'a, T>
 where
     T: Iterator<Item = &'a Gadget>,
 {
-    pub(crate) fn new(jingle: &JingleContext, gadgets: T, trace: Vec<ModeledInstruction>) -> Self {
+    pub(crate) fn new<S: Borrow<SleighArchInfo>>(
+        jingle: S,
+        gadgets: T,
+        trace: Vec<ModeledInstruction>,
+    ) -> Self {
         let _solver = Solver::new();
         Self {
-            jingle: jingle.clone(),
+            info: jingle.borrow().clone(),
             _solver,
             gadgets,
             trace,
@@ -53,12 +57,13 @@ where
                         i.instr.disassembly, gadget
                     );
 
-                    gadget_signature.covers(&GadgetSignature::from_instr(&i.instr, i))
+                    gadget_signature
+                        .covers(&GadgetSignature::from_instr(&i.instr, i.get_arch_info()))
                         && has_compatible_control_flow(&i.instr, gadget)
                 })
                 .collect();
             if is_candidate.iter().any(|b| *b) {
-                let model = gadget.model(&self.jingle);
+                let model = gadget.model(&self.info);
                 if let Ok(model) = &model {
                     is_candidate.iter().enumerate().for_each(|(i, c)| {
                         if *c {

crackers/src/gadget/candidates.rs

@@ -1,9 +1,9 @@
-use jingle::JingleContext;
-use jingle::modeling::ModeledBlock;
-
 use crate::error::CrackersError;
 use crate::error::CrackersError::UnsimulatedOperation;
 use crate::gadget::Gadget;
+use jingle::modeling::ModeledBlock;
+use jingle::sleigh::SleighArchInfo;
+use std::borrow::Borrow;
 
 #[derive(Clone, Debug, Default)]
 pub struct CandidateBuilder {
@@ -58,12 +58,16 @@ pub struct Candidates {
 }
 
 impl Candidates {
-    pub fn model(&self, jingle: &JingleContext) -> Result<Vec<Vec<ModeledBlock>>, CrackersError> {
+    pub fn model<T: Borrow<SleighArchInfo>>(
+        &self,
+        info: T,
+    ) -> Result<Vec<Vec<ModeledBlock>>, CrackersError> {
+        let info = info.borrow();
         let mut result = vec![];
         for x in &self.candidates {
             let mut v = vec![];
             for g in x {
-                v.push(g.model(jingle)?);
+                v.push(g.model(info)?);
             }
             result.push(v)
         }

crackers/src/gadget/library/mod.rs

@@ -1,10 +1,11 @@
+use jingle::JingleError;
 use jingle::modeling::ModeledInstruction;
 use jingle::sleigh::context::loaded::LoadedSleighContext;
-use jingle::sleigh::{ArchInfoProvider, Instruction, SleighArchInfo, SpaceInfo, VarNode};
-use jingle::{JingleContext, JingleError};
+use jingle::sleigh::{Instruction, SleighArchInfo};
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use rand::seq::IndexedRandom;
+use std::borrow::Borrow;
 use tracing::{Level, event};
 
 use crate::gadget::Gadget;
@@ -17,9 +18,13 @@ pub mod image;
 #[derive(Clone, Debug)]
 pub struct GadgetLibrary {
     pub(crate) gadgets: Vec<Gadget>,
-    spaces: Vec<SpaceInfo>,
-    default_code_space_index: usize,
-    registers: Vec<(VarNode, String)>,
+    arch_info: SleighArchInfo,
+}
+
+impl AsRef<SleighArchInfo> for GadgetLibrary {
+    fn as_ref(&self) -> &SleighArchInfo {
+        &self.arch_info
+    }
 }
 
 impl GadgetLibrary {
@@ -28,40 +33,25 @@ impl GadgetLibrary {
     }
 
     pub(crate) fn arch_info(&self) -> SleighArchInfo {
-        SleighArchInfo::new(
-            self.get_registers(),
-            self.get_all_space_info(),
-            self.default_code_space_index,
-        )
+        self.arch_info.clone()
     }
-    pub fn get_random_candidates_for_trace<'a>(
+    pub fn get_random_candidates_for_trace<'a, S: Borrow<SleighArchInfo>>(
         &'a self,
-        jingle: &JingleContext,
+        info: S,
         trace: &[ModeledInstruction],
         seed: i64,
     ) -> impl Iterator<Item = Vec<Option<&'a Gadget>>> {
         let mut rng = StdRng::seed_from_u64(seed as u64);
         let r = self.gadgets.choose_multiple(&mut rng, self.gadgets.len());
-        TraceCandidateIterator::new(jingle, r, trace.to_vec())
+        TraceCandidateIterator::new(info, r, trace.to_vec())
     }
     pub(super) fn build_from_image(
         sleigh: LoadedSleighContext,
         builder: &GadgetLibraryConfig,
     ) -> Result<Self, JingleError> {
-        let spaces: Vec<_> = sleigh.get_all_space_info().cloned().collect();
-        let mut registers = vec![];
-        let default_code_space_index = sleigh.get_code_space_idx();
-        for (varnode, register) in sleigh.get_registers() {
-            registers.push((varnode.clone(), register));
-        }
         let mut lib: GadgetLibrary = GadgetLibrary {
             gadgets: vec![],
-            spaces,
-            default_code_space_index,
-            registers: registers
-                .iter()
-                .map(|(varnode, register)| (varnode.clone(), register.to_string()))
-                .collect(),
+            arch_info: sleigh.arch_info().clone(),
         };
         event!(Level::INFO, "Loading gadgets from sleigh");
         for section in sleigh.get_sections().filter(|s| s.perms.exec) {
@@ -74,8 +64,8 @@ impl GadgetLibrary {
                     sleigh.read(curr, builder.max_gadget_length).collect();
                 if let Some(i) = instrs.iter().position(|b| b.terminates_basic_block()) {
                     let gadget = Gadget {
-                        code_space_idx: sleigh.get_code_space_idx(),
-                        spaces: sleigh.get_all_space_info().cloned().collect(),
+                        code_space_idx: sleigh.arch_info().default_code_space_index(),
+                        spaces: sleigh.arch_info().spaces().to_vec(),
                         instructions: instrs[0..=i].to_vec(),
                     };
                     if !gadget.has_blacklisted_op(&builder.operation_blacklist) {
@@ -90,37 +80,6 @@ impl GadgetLibrary {
     }
 }
 
-impl ArchInfoProvider for GadgetLibrary {
-    fn get_space_info(&self, idx: usize) -> Option<&SpaceInfo> {
-        self.spaces.get(idx)
-    }
-    fn get_all_space_info(&self) -> impl Iterator<Item = &SpaceInfo> {
-        self.spaces.iter()
-    }
-
-    fn get_code_space_idx(&self) -> usize {
-        self.default_code_space_index
-    }
-
-    fn get_register(&self, name: &str) -> Option<&VarNode> {
-        self.registers
-            .iter()
-            .find(|(_, reg_name)| reg_name.as_str() == name)
-            .map(|(vn, _)| vn)
-    }
-
-    fn get_register_name(&self, location: &VarNode) -> Option<&str> {
-        self.registers
-            .iter()
-            .find(|(vn, _)| vn == location)
-            .map(|(_, name)| name.as_str())
-    }
-
-    fn get_registers(&self) -> impl Iterator<Item = (&VarNode, &str)> {
-        self.registers.iter().map(|(vn, name)| (vn, name.as_str()))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::fs;

crackers/src/gadget/mod.rs

@@ -1,7 +1,7 @@
-use jingle::JingleContext;
 use jingle::modeling::ModeledBlock;
-use jingle::sleigh::{Instruction, OpCode, PcodeOperation, SpaceInfo};
+use jingle::sleigh::{Instruction, OpCode, PcodeOperation, SleighArchInfo, SpaceInfo};
 use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
 use std::collections::HashSet;
 use std::fmt::{Debug, Display, Formatter};
 
@@ -49,7 +49,10 @@ impl Gadget {
             .any(|i| i.ops.iter().any(|o| blacklist.contains(&o.opcode())))
     }
 
-    pub fn model(&self, jingle: &JingleContext) -> Result<ModeledBlock, CrackersError> {
+    pub fn model<I: Borrow<SleighArchInfo>>(
+        &self,
+        jingle: I,
+    ) -> Result<ModeledBlock, CrackersError> {
         let blk = ModeledBlock::read(jingle, self.instructions.clone().into_iter())?;
         Ok(blk)
     }