Rust 2024 Edition

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = ["crackers", "crackers_python"]
 
 [profile.dev]

crackers/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "crackers"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

crackers/src/bench/mod.rs

@@ -3,11 +3,11 @@ use std::path::PathBuf;
 
 use clap::Parser;
 use tracing::level_filters::LevelFilter;
-use tracing::{event, Level};
+use tracing::{Level, event};
 use tracing_indicatif::IndicatifLayer;
+use tracing_subscriber::EnvFilter;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
-use tracing_subscriber::EnvFilter;
 use z3::{Config, Context};
 
 use crate::config::CrackersConfig;

crackers/src/bin/crackers/main.rs

@@ -4,22 +4,22 @@ use std::path::PathBuf;
 
 use clap::{Parser, Subcommand};
 use toml_edit::ser::to_string_pretty;
-use tracing::{event, Level};
+use tracing::{Level, event};
 use tracing_indicatif::IndicatifLayer;
+use tracing_subscriber::EnvFilter;
 use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
-use tracing_subscriber::EnvFilter;
 use z3::{Config, Context};
 
-use crackers::bench::{bench, BenchCommand};
+use crackers::bench::{BenchCommand, bench};
+use crackers::config::CrackersConfig;
 use crackers::config::constraint::{
     ConstraintConfig, MemoryEqualityConstraint, PointerRange, PointerRangeConstraints,
     StateEqualityConstraint,
 };
 use crackers::config::sleigh::SleighConfig;
 use crackers::config::specification::SpecificationConfig;
-use crackers::config::CrackersConfig;
 use crackers::synthesis::DecisionResult;
 
 #[derive(Parser, Debug)]

crackers/src/config/constraint.rs

@@ -1,17 +1,17 @@
 use crate::error::CrackersError;
 use crate::synthesis::builder::{StateConstraintGenerator, TransitionConstraintGenerator};
+use jingle::JingleContext;
 use jingle::modeling::{ModeledBlock, ModelingContext, State};
 use jingle::sleigh::{ArchInfoProvider, VarNode};
 use jingle::varnode::{ResolvedIndirectVarNode, ResolvedVarnode};
-use jingle::JingleContext;
 #[cfg(feature = "pyo3")]
 use pyo3::pyclass;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::ops::Add;
 use std::sync::Arc;
-use tracing::{event, Level};
-use z3::ast::{Ast, Bool, BV};
+use tracing::{Level, event};
+use z3::ast::{Ast, BV, Bool};
 
 #[derive(Clone, Debug, Deserialize, Serialize, Default)]
 #[cfg_attr(feature = "pyo3", pyclass(get_all, set_all))]
@@ -129,10 +129,10 @@ pub struct PointerRange {
 pub fn gen_memory_constraint(
     m: MemoryEqualityConstraint,
 ) -> impl for<'a> Fn(&JingleContext<'a>, &State<'a>, u64) -> Result<Bool<'a>, CrackersError>
-       + Send
-       + Sync
-       + Clone
-       + 'static {
++ Send
++ Sync
++ Clone
++ 'static {
     move |jingle, state, _addr| {
         let data = state.read_varnode(&state.varnode(&m.space, m.address, m.size).unwrap())?;
         let constraint = data._eq(&BV::from_u64(jingle.z3, m.value as u64, data.get_size()));
@@ -146,10 +146,10 @@ pub fn gen_register_constraint(
     vn: VarNode,
     value: u64,
 ) -> impl for<'a> Fn(&JingleContext<'a>, &State<'a>, u64) -> Result<Bool<'a>, CrackersError>
-       + 'static
-       + Send
-       + Sync
-       + Clone {
++ 'static
++ Send
++ Sync
++ Clone {
     move |jingle, state, _addr| {
         let data = state.read_varnode(&vn)?;
         let constraint = data._eq(&BV::from_u64(jingle.z3, value, data.get_size()));
@@ -209,8 +209,8 @@ pub fn gen_pointer_range_state_invariant<'ctx>(
     &ResolvedVarnode<'a>,
     &State<'a>,
 ) -> Result<Option<Bool<'a>>, CrackersError>
-       + 'ctx
-       + Clone {
++ 'ctx
++ Clone {
     move |jingle, vn, state| {
         match vn {
             ResolvedVarnode::Direct(d) => {
@@ -245,10 +245,10 @@ pub fn gen_pointer_range_state_invariant<'ctx>(
 pub fn gen_pointer_range_transition_invariant(
     m: PointerRangeConstraints,
 ) -> impl for<'a> Fn(&JingleContext<'a>, &ModeledBlock<'a>) -> Result<Option<Bool<'a>>, CrackersError>
-       + Send
-       + Sync
-       + Clone
-       + 'static {
++ Send
++ Sync
++ Clone
++ 'static {
     move |jingle, block| {
         let mut bools = vec![];
         if let Some(r) = &m.read {

crackers/src/config/error.rs

@@ -1,5 +1,5 @@
-use jingle::sleigh::JingleSleighError;
 use jingle::JingleError;
+use jingle::sleigh::JingleSleighError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -16,7 +16,9 @@ pub enum CrackersConfigError {
     LibraryParse,
     #[error("Spec objects must have a '.text' symbol")]
     SpecMissingTextSection,
-    #[error("Unable to determine the architecture of the provided object file. This is a config file limitation and not a sleigh limitation.")]
+    #[error(
+        "Unable to determine the architecture of the provided object file. This is a config file limitation and not a sleigh limitation."
+    )]
     UnrecognizedArchitecture(String),
     #[error("An error initializing sleigh for a file specified in the config")]
     Sleigh(#[from] JingleError),

crackers/src/config/object.rs

@@ -3,7 +3,7 @@
 use std::fs;
 use std::path::Path;
 
-use jingle::sleigh::context::image::gimli::{map_gimli_architecture, OwnedFile};
+use jingle::sleigh::context::image::gimli::{OwnedFile, map_gimli_architecture};
 use jingle::sleigh::context::loaded::LoadedSleighContext;
 use object::{File, Object};
 

crackers/src/config/specification.rs

@@ -1,7 +1,7 @@
 use std::fs;
 
-use jingle::sleigh::context::loaded::LoadedSleighContext;
 use jingle::sleigh::Instruction;
+use jingle::sleigh::context::loaded::LoadedSleighContext;
 use object::{File, Object, ObjectSymbol};
 #[cfg(feature = "pyo3")]
 use pyo3::{pyclass, pymethods};

crackers/src/error.rs

@@ -1,8 +1,8 @@
 use jingle::JingleError;
 #[cfg(feature = "pyo3")]
-use pyo3::exceptions::PyRuntimeError;
-#[cfg(feature = "pyo3")]
 use pyo3::PyErr;
+#[cfg(feature = "pyo3")]
+use pyo3::exceptions::PyRuntimeError;
 use thiserror::Error;
 
 use crate::config::error::CrackersConfigError;

crackers/src/gadget/another_iterator.rs

@@ -1,12 +1,12 @@
+use jingle::JingleContext;
 use jingle::modeling::{ModeledInstruction, ModelingContext};
 use jingle::sleigh::{Instruction, OpCode};
-use jingle::JingleContext;
 use tracing::trace;
-use z3::ast::Ast;
 use z3::Solver;
+use z3::ast::Ast;
 
-use crate::gadget::signature::GadgetSignature;
 use crate::gadget::Gadget;
+use crate::gadget::signature::GadgetSignature;
 
 pub struct TraceCandidateIterator<'ctx, 'a, T>
 where
@@ -54,8 +54,7 @@ where
                 .map(|i| {
                     trace!(
                         "Checking {} signature vs gadget {}",
-                        i.instr.disassembly,
-                        gadget
+                        i.instr.disassembly, gadget
                     );
 
                     gadget_signature.covers(&GadgetSignature::from_instr(&i.instr, i))

crackers/src/gadget/candidates.rs

@@ -1,5 +1,5 @@
-use jingle::modeling::ModeledBlock;
 use jingle::JingleContext;
+use jingle::modeling::ModeledBlock;
 
 use crate::error::CrackersError;
 use crate::error::CrackersError::UnsimulatedOperation;

crackers/src/gadget/library/image.rs

@@ -1,8 +1,8 @@
 use crate::error::CrackersError;
-use jingle::sleigh::context::image::{ImageProvider, ImageSection, ImageSectionIterator, Perms};
+use jingle::JingleError::Sleigh;
 use jingle::sleigh::JingleSleighError::ImageLoadError;
 use jingle::sleigh::VarNode;
-use jingle::JingleError::Sleigh;
+use jingle::sleigh::context::image::{ImageProvider, ImageSection, ImageSectionIterator, Perms};
 use object::elf::{PF_R, PF_W, PF_X};
 use object::macho::{VM_PROT_EXECUTE, VM_PROT_READ, VM_PROT_WRITE};
 use object::pe::{IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ, IMAGE_SCN_MEM_WRITE};

crackers/src/gadget/library/mod.rs

@@ -2,14 +2,14 @@ use jingle::modeling::ModeledInstruction;
 use jingle::sleigh::context::loaded::LoadedSleighContext;
 use jingle::sleigh::{ArchInfoProvider, Instruction, SpaceInfo, VarNode};
 use jingle::{JingleContext, JingleError};
+use rand::SeedableRng;
 use rand::rngs::StdRng;
 use rand::seq::SliceRandom;
-use rand::SeedableRng;
-use tracing::{event, Level};
+use tracing::{Level, event};
 
+use crate::gadget::Gadget;
 use crate::gadget::another_iterator::TraceCandidateIterator;
 use crate::gadget::library::builder::GadgetLibraryConfig;
-use crate::gadget::Gadget;
 
 pub mod builder;
 pub mod image;
@@ -119,8 +119,8 @@ mod tests {
     use std::fs;
     use std::path::Path;
 
-    use crate::gadget::library::builder::GadgetLibraryConfig;
     use crate::gadget::library::GadgetLibrary;
+    use crate::gadget::library::builder::GadgetLibraryConfig;
     use jingle::sleigh::context::SleighContextBuilder;
     use object::File;
 

crackers/src/gadget/mod.rs

@@ -1,6 +1,6 @@
+use jingle::JingleContext;
 use jingle::modeling::ModeledBlock;
 use jingle::sleigh::{Instruction, OpCode, PcodeOperation, SpaceInfo};
-use jingle::JingleContext;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::fmt::{Debug, Display, Formatter};

crackers/src/synthesis/assignment_model.rs

@@ -3,8 +3,8 @@ use std::fmt::{Display, Formatter};
 use jingle::modeling::{ModelingContext, State};
 use jingle::sleigh::{ArchInfoProvider, GeneralizedVarNode};
 use jingle::varnode::ResolvedVarnode;
-use z3::ast::BV;
 use z3::Model;
+use z3::ast::BV;
 
 #[derive(Debug)]
 pub struct AssignmentModel<'ctx, T: ModelingContext<'ctx>> {

crackers/src/synthesis/builder.rs

@@ -1,20 +1,20 @@
 use std::sync::Arc;
 
 use derive_builder::Builder;
+use jingle::JingleContext;
 use jingle::modeling::{ModeledBlock, State};
 use jingle::sleigh::Instruction;
-use jingle::JingleContext;
 #[cfg(feature = "pyo3")]
 use pyo3::pyclass;
 use serde::{Deserialize, Serialize};
-use z3::ast::Bool;
 use z3::Context;
+use z3::ast::Bool;
 
 use crate::error::CrackersError;
-use crate::gadget::library::builder::GadgetLibraryConfig;
 use crate::gadget::library::GadgetLibrary;
-use crate::synthesis::combined::CombinedAssignmentSynthesis;
+use crate::gadget::library::builder::GadgetLibraryConfig;
 use crate::synthesis::AssignmentSynthesis;
+use crate::synthesis::combined::CombinedAssignmentSynthesis;
 
 #[derive(Copy, Clone, Debug, Deserialize, Serialize)]
 #[cfg_attr(feature = "pyo3", pyclass)]

crackers/src/synthesis/combined.rs

@@ -1,6 +1,6 @@
 use jingle::modeling::ModeledBlock;
 use jingle::sleigh::Instruction;
-use tracing::{event, Level};
+use tracing::{Level, event};
 use z3::Context;
 
 use crate::error::CrackersError;

crackers/src/synthesis/mod.rs

@@ -1,9 +1,9 @@
+use jingle::JingleContext;
 use jingle::modeling::{ModeledBlock, ModeledInstruction, ModelingContext};
 use jingle::sleigh::Instruction;
-use jingle::JingleContext;
 use std::cmp::Ordering;
 use std::sync::Arc;
-use tracing::{event, instrument, Level};
+use tracing::{Level, event, instrument};
 use z3::{Config, Context, Solver};
 
 use crate::error::CrackersError;
@@ -18,10 +18,10 @@ use crate::synthesis::builder::{
 use crate::synthesis::pcode_theory::builder::PcodeTheoryBuilder;
 use crate::synthesis::pcode_theory::pcode_assignment::PcodeAssignment;
 use crate::synthesis::pcode_theory::theory_worker::TheoryWorker;
-use crate::synthesis::selection_strategy::optimization_problem::OptimizationProblem;
-use crate::synthesis::selection_strategy::sat_problem::SatProblem;
 use crate::synthesis::selection_strategy::AssignmentResult::{Failure, Success};
 use crate::synthesis::selection_strategy::OuterProblem::{OptimizeProb, SatProb};
+use crate::synthesis::selection_strategy::optimization_problem::OptimizationProblem;
+use crate::synthesis::selection_strategy::sat_problem::SatProblem;
 use crate::synthesis::selection_strategy::{OuterProblem, SelectionFailure, SelectionStrategy};
 
 pub mod assignment_model;

crackers/src/synthesis/pcode_theory/builder.rs

@@ -1,16 +1,16 @@
 use std::sync::Arc;
 
+use jingle::JingleContext;
 use jingle::modeling::{ModeledBlock, ModeledInstruction};
 use jingle::sleigh::Instruction;
-use jingle::JingleContext;
 use z3::Context;
 
 use crate::error::CrackersError;
 use crate::gadget::candidates::Candidates;
 use crate::gadget::library::GadgetLibrary;
 use crate::synthesis::builder::{StateConstraintGenerator, TransitionConstraintGenerator};
-use crate::synthesis::pcode_theory::pcode_assignment::PcodeAssignment;
 use crate::synthesis::pcode_theory::PcodeTheory;
+use crate::synthesis::pcode_theory::pcode_assignment::PcodeAssignment;
 use crate::synthesis::slot_assignments::SlotAssignments;
 
 #[derive(Clone)]

crackers/src/synthesis/pcode_theory/mod.rs

@@ -1,24 +1,24 @@
 use std::sync::Arc;
 
-use jingle::modeling::{ModeledBlock, ModelingContext, State};
 use jingle::JingleContext;
-use tracing::{event, Level};
+use jingle::modeling::{ModeledBlock, ModelingContext, State};
+use tracing::{Level, event};
 use z3::ast::Bool;
 use z3::{SatResult, Solver};
 
 use conflict_clause::ConflictClause;
 
 use crate::error::CrackersError;
 use crate::error::CrackersError::TheoryTimeout;
+use crate::synthesis::Decision;
 use crate::synthesis::builder::{StateConstraintGenerator, TransitionConstraintGenerator};
 use crate::synthesis::pcode_theory::pcode_assignment::{
     assert_compatible_semantics, assert_concat, assert_state_constraints,
 };
 use crate::synthesis::pcode_theory::theory_constraint::{
-    gen_conflict_clauses, ConjunctiveConstraint, TheoryStage,
+    ConjunctiveConstraint, TheoryStage, gen_conflict_clauses,
 };
 use crate::synthesis::slot_assignments::SlotAssignments;
-use crate::synthesis::Decision;
 
 pub mod builder;
 pub mod conflict_clause;

crackers/src/synthesis/pcode_theory/pcode_assignment.rs

@@ -1,5 +1,5 @@
-use jingle::modeling::{ModeledBlock, ModeledInstruction, ModelingContext, State};
 use jingle::JingleContext;
+use jingle::modeling::{ModeledBlock, ModeledInstruction, ModelingContext, State};
 use std::sync::Arc;
 use z3::ast::Bool;
 use z3::{Context, SatResult, Solver};

crackers/src/synthesis/pcode_theory/theory_constraint.rs

@@ -1,7 +1,7 @@
 use z3::ast::Bool;
 
-use crate::synthesis::pcode_theory::conflict_clause::ConflictClause;
 use crate::synthesis::Decision;
+use crate::synthesis::pcode_theory::conflict_clause::ConflictClause;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum TheoryStage {