Signature tweaks

Author: toolCHAINZ

src/gadget/another_iterator.rs

@@ -1,5 +1,6 @@
 use jingle::modeling::{ModeledInstruction, ModelingContext};
 use jingle::sleigh::{Instruction, OpCode};
+use tracing::{instrument, trace};
 use z3::ast::Ast;
 use z3::{Context, Solver};
 
@@ -41,11 +42,14 @@ where
         loop {
             let gadget = self.gadgets.next()?;
             let gadget_signature = GadgetSignature::from(gadget);
+            trace!("Evaluating gadget at {:x}", gadget.address());
             let is_candidate: Vec<bool> = self
                 .trace
                 .iter()
                 .map(|i| {
-                    gadget_signature.covers(&GadgetSignature::from(&i.instr))
+                    trace!("Checking {} signature vs gadget {}", i.instr.disassembly, gadget);
+
+                    gadget_signature.covers(&GadgetSignature::from_instr(&i.instr, i))
                         && has_compatible_control_flow(&i.instr, gadget)
                 })
                 .collect();
@@ -63,6 +67,8 @@ where
                             }
                         }
                     })
+                }else{
+                    trace!("Could not model gadget: \n{}", gadget)
                 }
                 return Some(next_entry);
             } else {

src/gadget/mod.rs

@@ -25,8 +25,8 @@ pub struct Gadget {
 }
 
 impl Gadget {
-    pub fn address(&self) -> Option<u64> {
-        self.instructions.first().map(|f| f.address)
+    pub fn address(&self) -> u64 {
+        self.instructions.first().map(|f| f.address).unwrap()
     }
 
     pub fn ops(&self) -> impl Iterator<Item = &PcodeOperation> {

src/gadget/signature.rs

@@ -1,21 +1,20 @@
 use std::cmp::Ordering;
 
-use jingle::modeling::ModeledBlock;
-use jingle::sleigh::{GeneralizedVarNode, IndirectVarNode, Instruction, VarNode};
-
 use crate::gadget::Gadget;
+use jingle::modeling::ModeledBlock;
+use jingle::sleigh::{GeneralizedVarNode, IndirectVarNode, Instruction, SpaceManager, SpaceType, VarNode};
+use tracing::trace;
 
 #[derive(Clone, Debug)]
 pub struct GadgetSignature {
     outputs: Vec<GeneralizedVarNode>,
-    #[allow(unused)]
-    inputs: Vec<GeneralizedVarNode>,
 }
 
 impl GadgetSignature {
     /// For now this is very naive; just want a very rough filter to make sure we aren't
     /// throwing completely pointless work at z3
     pub fn covers(&self, other: &GadgetSignature) -> bool {
+        trace!("{:?} vs {:?}", self.outputs, other.outputs);
         varnode_set_covers(&self.outputs, &other.outputs)
     }
 
@@ -45,18 +44,24 @@ impl PartialOrd<GadgetSignature> for GadgetSignature {
         }
     }
 }
-impl From<&Instruction> for GadgetSignature {
-    fn from(value: &Instruction) -> Self {
+impl GadgetSignature {
+    pub(crate) fn from_instr<T: SpaceManager>(value: &Instruction, t: &T) -> Self {
         let mut outputs = Vec::new();
-        let mut inputs = Vec::new();
 
         for op in &value.ops {
             if let Some(op) = op.output() {
-                outputs.push(op);
+                if let GeneralizedVarNode::Direct(v) = &op {
+                    if let Some(h) = t.get_space_info(v.space_index){
+                        if h._type == SpaceType::IPTR_PROCESSOR{
+                            outputs.push(op);
+                        }
+                    }
+                } else {
+                    outputs.push(op);
+                }
             }
-            inputs.extend(op.inputs())
         }
-        Self { outputs, inputs }
+        Self { outputs }
     }
 }
 
@@ -72,21 +77,27 @@ impl<'ctx> From<&ModeledBlock<'ctx>> for GadgetSignature {
                 inputs.extend(op.inputs())
             }
         }
-        Self { outputs, inputs }
+        Self { outputs }
     }
 }
 
 impl From<&Gadget> for GadgetSignature {
     fn from(value: &Gadget) -> Self {
         let mut outputs = Vec::new();
-        let mut inputs = Vec::new();
         for op in value.instructions.iter().flat_map(|i| &i.ops) {
             if let Some(op) = op.output() {
-                outputs.push(op);
+                if let GeneralizedVarNode::Direct(v) = &op {
+                    if let Some(h) = value.get_space_info(v.space_index){
+                        if h._type == SpaceType::IPTR_PROCESSOR{
+                            outputs.push(op);
+                        }
+                    }
+                } else {
+                    outputs.push(op);
+                }
             }
-            inputs.extend(op.inputs())
         }
-        Self { outputs, inputs }
+        Self { outputs }
     }
 }
 
@@ -139,23 +150,13 @@ mod tests {
                 space_index: 0,
                 offset: 0,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         let o2 = GadgetSignature {
             outputs: vec![Direct(VarNode {
                 size: 4,
                 space_index: 0,
                 offset: 0,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         assert!(o1.covers(&o2));
         assert!(o2.covers(&o1));
@@ -172,23 +173,13 @@ mod tests {
                 space_index: 0,
                 offset: 0,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         let o2 = GadgetSignature {
             outputs: vec![Direct(VarNode {
                 size: 4,
                 space_index: 0,
                 offset: 3,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         assert_ne!(o1, o2);
         assert!(!o1.covers(&o2));
@@ -203,23 +194,13 @@ mod tests {
                 space_index: 0,
                 offset: 0,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         let o2 = GadgetSignature {
             outputs: vec![Direct(VarNode {
                 size: 4,
                 space_index: 0,
                 offset: 4,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         assert!(!o1.covers(&o2));
         assert!(!o2.covers(&o1));
@@ -233,11 +214,6 @@ mod tests {
                 space_index: 0,
                 offset: 7,
             })],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         let o2 = GadgetSignature {
             outputs: vec![
@@ -262,11 +238,6 @@ mod tests {
                     offset: 16,
                 }),
             ],
-            inputs: vec![Direct(VarNode {
-                size: 4,
-                space_index: 0,
-                offset: 0,
-            })],
         };
         assert!(o2.covers(&o1));
         assert!(!o1.covers(&o2));