angr 9.2.159__cp310-abi3-macosx_11_0_arm64.whl → 9.2.160__cp310-abi3-macosx_11_0_arm64.whl

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.159"
+__version__ = "9.2.160"
 
 if bytes is str:
     raise Exception(

angr/analyses/decompiler/clinic.py

@@ -143,7 +143,8 @@ class Clinic(Analysis):
         desired_variables: set[str] | None = None,
         force_loop_single_exit: bool = True,
         complete_successors: bool = False,
-        max_type_constraints: int = 4000,
+        max_type_constraints: int = 100_000,
+        type_constraint_set_degradation_threshold: int = 150,
         ail_graph: networkx.DiGraph | None = None,
         arg_vvars: dict[int, tuple[ailment.Expr.VirtualVariable, SimVariable]] | None = None,
         start_stage: ClinicStage | None = ClinicStage.INITIALIZATION,
@@ -185,6 +186,7 @@ class Clinic(Analysis):
         self._cache = cache
         self._mode = mode
         self._max_type_constraints = max_type_constraints
+        self._type_constraint_set_degradation_threshold = type_constraint_set_degradation_threshold
         self.vvar_id_start = vvar_id_start
         self.vvar_to_vvar: dict[int, int] | None = None
         # during SSA conversion, we create secondary stack variables because they overlap and are larger than the
@@ -1871,6 +1873,7 @@ class Clinic(Analysis):
                     must_struct=must_struct,
                     ground_truth=groundtruth,
                     stackvar_max_sizes=tv_max_sizes,
+                    constraint_set_degradation_threshold=self._type_constraint_set_degradation_threshold,
                 )
                 # tp.pp_constraints()
                 # tp.pp_solution()

angr/analyses/decompiler/decompiler.py

@@ -23,7 +23,7 @@ from .ailgraph_walker import AILGraphWalker
 from .condition_processor import ConditionProcessor
 from .decompilation_options import DecompilationOption
 from .decompilation_cache import DecompilationCache
-from .utils import remove_labels, remove_edges_in_ailgraph
+from .utils import remove_edges_in_ailgraph
 from .sequence_walker import SequenceWalker
 from .structuring.structurer_nodes import SequenceNode
 from .presets import DECOMPILATION_PRESETS, DecompilationPreset
@@ -319,12 +319,8 @@ class Decompiler(Analysis):
         # removed!
         remove_edges_in_ailgraph(clinic.graph, clinic.edges_to_remove)
 
-        # Rewrite the graph to remove phi expressions
-        # this is probably optional if we do not pretty-print clinic.graph
-        clinic.graph = self._transform_graph_from_ssa(clinic.graph)
-
         # save the graph before structuring happens (for AIL view)
-        clinic.cc_graph = remove_labels(clinic.copy_graph())
+        clinic.cc_graph = clinic.copy_graph()
 
         codegen = None
         seq_node = None
@@ -357,7 +353,7 @@ class Decompiler(Analysis):
             )
 
             # rewrite the sequence node to remove phi expressions
-            seq_node = self._transform_seqnode_from_ssa(seq_node)
+            seq_node = self.transform_seqnode_from_ssa(seq_node)
 
             # update memory data
             if self._cfg is not None and self._update_memory_data:
@@ -670,14 +666,21 @@ class Decompiler(Analysis):
             memory_data_addrs=added_memory_data_addrs,
         )
 
-    def _transform_graph_from_ssa(self, ail_graph: networkx.DiGraph) -> networkx.DiGraph:
+    def transform_graph_from_ssa(self, ail_graph: networkx.DiGraph) -> networkx.DiGraph:
+        """
+        Translate an SSA AIL graph out of SSA form. This is useful for producing a non-SSA AIL graph for displaying in
+        angr management.
+
+        :param ail_graph:   The AIL graph to transform out of SSA form.
+        :return:            The translated AIL graph.
+        """
         variable_kb = self._variable_kb
         dephication = self.project.analyses.GraphDephication(
             self.func, ail_graph, rewrite=True, variable_kb=variable_kb, kb=self.kb, fail_fast=self._fail_fast
         )
         return dephication.output
 
-    def _transform_seqnode_from_ssa(self, seq_node: SequenceNode) -> SequenceNode:
+    def transform_seqnode_from_ssa(self, seq_node: SequenceNode) -> SequenceNode:
         variable_kb = self._variable_kb
         dephication = self.project.analyses.SeqNodeDephication(
             self.func, seq_node, rewrite=True, variable_kb=variable_kb, kb=self.kb, fail_fast=self._fail_fast

angr/analyses/typehoon/simple_solver.py

@@ -1,4 +1,4 @@
-# pylint:disable=missing-class-docstring
+# pylint:disable=missing-class-docstring,too-many-boolean-expressions
 from __future__ import annotations
 import enum
 from collections import defaultdict
@@ -432,7 +432,14 @@ class SimpleSolver:
     improvements.
     """
 
-    def __init__(self, bits: int, constraints, typevars, stackvar_max_sizes: dict[TypeVariable, int] | None = None):
+    def __init__(
+        self,
+        bits: int,
+        constraints,
+        typevars,
+        constraint_set_degradation_threshold: int = 150,
+        stackvar_max_sizes: dict[TypeVariable, int] | None = None,
+    ):
         if bits not in (32, 64):
             raise ValueError(f"Pointer size {bits} is not supported. Expect 32 or 64.")
 
@@ -440,6 +447,7 @@ class SimpleSolver:
         self._constraints: dict[TypeVariable, set[TypeConstraint]] = constraints
         self._typevars: set[TypeVariable] = typevars
         self.stackvar_max_sizes = stackvar_max_sizes if stackvar_max_sizes is not None else {}
+        self._constraint_set_degradation_threshold = constraint_set_degradation_threshold
         self._base_lattice = BASE_LATTICES[bits]
         self._base_lattice_inverted = networkx.DiGraph()
         for src, dst in self._base_lattice.edges:
@@ -459,7 +467,11 @@ class SimpleSolver:
                 self.processed_constraints_count += len(self._constraints[typevar])
 
                 self._constraints[typevar] |= self._eq_constraints_from_add(typevar)
-                self._constraints[typevar] = self._handle_equivalence(typevar)
+                self._constraints[typevar] |= self._discover_equivalence(self._constraints[typevar])
+                new_constraints, replacements = self._handle_equivalence(self._constraints[typevar])
+                self._equivalence |= replacements
+                self._constraints[typevar] = new_constraints
+                self._constraints[typevar] = self._filter_constraints(self._constraints[typevar])
 
                 self.simplified_constraints_count += len(self._constraints[typevar])
 
@@ -517,11 +529,18 @@ class SimpleSolver:
 
         _, sketches = self.infer_shapes(typevars, constraints)
         constraintset2tvs = defaultdict(set)
+        tvs_seen = set()
         for idx, tv in enumerate(constrained_typevars):
             _l.debug("Collecting constraints for type variable %r (%d/%d)", tv, idx + 1, len(constrained_typevars))
+            if tv in tvs_seen:
+                continue
             # build a sub constraint set for the type variable
-            constraint_subset = frozenset(self._generate_constraint_subset(constraints, {tv}))
-            constraintset2tvs[constraint_subset].add(tv)
+            constraint_subset, related_tvs = self._generate_constraint_subset(constraints, {tv})
+            # drop all type vars outside constrained_typevars
+            related_tvs = related_tvs.intersection(constrained_typevars)
+            tvs_seen |= related_tvs
+            frozen_constraint_subset = frozenset(constraint_subset)
+            constraintset2tvs[frozen_constraint_subset] = related_tvs
 
         for idx, (constraint_subset, tvs) in enumerate(constraintset2tvs.items()):
             _l.debug(
@@ -534,8 +553,31 @@ class SimpleSolver:
             )
             self.eqclass_constraints_count.append(len(constraint_subset))
 
-            while True:
-                base_constraint_graph = self._generate_constraint_graph(constraint_subset, tvs | PRIMITIVE_TYPES)
+            if len(constraint_subset) > self._constraint_set_degradation_threshold:
+                _l.debug(
+                    "Constraint subset contains %d constraints, which is over the limit of %d. Enter degradation.",
+                    len(constraint_subset),
+                    self._constraint_set_degradation_threshold,
+                )
+                constraint_subset = self._degrade_constraint_set(constraint_subset)
+                _l.debug("Degraded constraint subset to %d constraints.", len(constraint_subset))
+
+            while constraint_subset:
+
+                _l.debug("Working with %d constraints.", len(constraint_subset))
+
+                # remove constraints that are a <: b where a only appears once; in this case, the solution fo a is
+                # entirely determined by the solution of b (which is the upper bound of a)
+                filtered_constraint_subset, ub_subtypes = self._filter_leaf_typevars(constraint_subset, tvs)
+                _l.debug(
+                    "Filtered %d leaf typevars; %d constraints remain.",
+                    len(ub_subtypes),
+                    len(filtered_constraint_subset),
+                )
+
+                base_constraint_graph = self._generate_constraint_graph(
+                    filtered_constraint_subset, tvs | PRIMITIVE_TYPES
+                )
                 primitive_constraints = self._generate_primitive_constraints(tvs, base_constraint_graph)
                 tvs_with_primitive_constraints = set()
                 for primitive_constraint in primitive_constraints:
@@ -546,12 +588,22 @@ class SimpleSolver:
                 solutions = {}
                 self.determine(sketches, tvs_with_primitive_constraints, solutions)
                 _l.debug("Determined solutions for %d type variable(s).", len(tvs_with_primitive_constraints))
+
+                leaf_solutions = 0
+                for tv_, ub_tv in ub_subtypes.items():
+                    if ub_tv in solutions:
+                        solutions[tv_] = solutions[ub_tv]
+                        leaf_solutions += 1
+                    elif isinstance(ub_tv, TypeConstant):
+                        solutions[tv_] = ub_tv
+                        leaf_solutions += 1
+                _l.debug("Determined solutions for %d leaf type variable(s).", leaf_solutions)
+
                 if not solutions:
                     break
-
                 self.solution |= solutions
 
-                tvs = {tv for tv in tvs if tv not in tvs_with_primitive_constraints}
+                tvs = {tv for tv in tvs if tv not in solutions}
                 if not tvs:
                     break
                 # rewrite existing constraints
@@ -559,7 +611,7 @@ class SimpleSolver:
                 for constraint in constraint_subset:
                     rewritten = self._rewrite_constraint(constraint, solutions)
                     new_constraint_subset.add(rewritten)
-                constraint_subset = new_constraint_subset
+                constraint_subset = self._filter_constraints(new_constraint_subset)
 
         # set the solution for missing type vars to TOP
         self.determine(sketches, set(sketches).difference(set(self.solution)), self.solution)
@@ -775,14 +827,45 @@ class SimpleSolver:
                     new_constraints.add(Equivalence(constraint.type_1, constraint.type_r))
         return new_constraints
 
-    def _handle_equivalence(self, typevar: TypeVariable):
+    @staticmethod
+    def _discover_equivalence(constraints: set[TypeConstraint]) -> set[Equivalence]:
+        """
+        a <:b && b <: a  ==>  a == b
+        """
+
+        new_eq_constraints: set[Equivalence] = set()
+        subtypes = defaultdict(set)
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                sub_type = constraint.sub_type
+                super_type = constraint.super_type
+                subtypes[sub_type].add(super_type)
+
+        # check everything
+        seen = set()
+        for tv, tv_supers in subtypes.items():
+            for tv_super in tv_supers:
+                if tv_super in subtypes and tv in subtypes[tv_super]:  # noqa: SIM102
+                    # we have a pair of subtypes that are equivalent
+                    if (tv, tv_super) not in seen and (tv_super, tv) not in seen:
+                        new_eq_constraints.add(Equivalence(tv, tv_super))
+                        seen.add((tv, tv_super))
+
+        _l.debug(
+            "Discovered %d equivalence constraints from %d constraints.", len(new_eq_constraints), len(constraints)
+        )
+        return new_eq_constraints
+
+    @staticmethod
+    def _handle_equivalence(
+        constraint_set: set[TypeConstraint],
+    ) -> tuple[set[TypeConstraint], dict[TypeVariable, TypeVariable | TypeConstant]]:
         graph = networkx.Graph()
 
-        replacements = {}
-        constraints = set()
+        replacements: dict[TypeVariable, TypeVariable | TypeConstant] = {}
 
         # collect equivalence relations
-        for constraint in self._constraints[typevar]:
+        for constraint in constraint_set:
             if isinstance(constraint, Equivalence):
                 # | type_a == type_b
                 # we apply unification and removes one of them
@@ -803,15 +886,30 @@ class SimpleSolver:
             for tv in components_lst[1:]:
                 replacements[tv] = representative
 
-        # replace
-        for constraint in self._constraints[typevar]:
+        constraints = SimpleSolver._rewrite_constraints_with_replacements(constraint_set, replacements)
+
+        # import pprint
+        # print("Replacements")
+        # pprint.pprint(replacements)
+        # print("Constraints (after replacement)")
+        # pprint.pprint(constraints)
+
+        return constraints, replacements
+
+    @staticmethod
+    def _rewrite_constraints_with_replacements(
+        constraints: set[TypeConstraint], replacements: dict[TypeVariable, TypeVariable]
+    ) -> set[TypeConstraint]:
+        # replace constraints according to a dictionary of type variable replacements
+        replaced_constraints = set()
+        for constraint in constraints:
             if isinstance(constraint, Existence):
                 replaced, new_constraint = constraint.replace(replacements)
 
                 if replaced:
-                    constraints.add(new_constraint)
+                    replaced_constraints.add(new_constraint)
                 else:
-                    constraints.add(constraint)
+                    replaced_constraints.add(constraint)
 
             elif isinstance(constraint, Subtype):
                 # subtype <: supertype
@@ -819,18 +917,122 @@ class SimpleSolver:
                 replaced, new_constraint = constraint.replace(replacements)
 
                 if replaced:
-                    constraints.add(new_constraint)
+                    replaced_constraints.add(new_constraint)
                 else:
-                    constraints.add(constraint)
+                    replaced_constraints.add(constraint)
+        return replaced_constraints
 
-        # import pprint
-        # print("Replacements")
-        # pprint.pprint(replacements)
-        # print("Constraints (after replacement)")
-        # pprint.pprint(constraints)
+    @staticmethod
+    def _filter_constraints(constraints: set[TypeConstraint]) -> set[TypeConstraint]:
+        """
+        Filter out constraints that we don't yet support.
+        """
+
+        filtered_constraints = set()
+        for constraint in constraints:
+            dropped = False
+            if isinstance(constraint, Subtype) and (
+                (isinstance(constraint.sub_type, TypeConstant) and isinstance(constraint.super_type, TypeConstant))
+                or (
+                    isinstance(constraint.sub_type, DerivedTypeVariable)
+                    and isinstance(constraint.sub_type.labels[-1], ConvertTo)
+                )
+                or (
+                    isinstance(constraint.sub_type, TypeVariable)
+                    and isinstance(constraint.super_type, TypeVariable)
+                    and constraint.sub_type == constraint.super_type
+                )
+            ):
+                dropped = True
 
-        self._equivalence = replacements
-        return constraints
+            if not dropped:
+                filtered_constraints.add(constraint)
+
+        return filtered_constraints
+
+    @staticmethod
+    def _filter_leaf_typevars(
+        constraints: set[TypeConstraint], tvs_to_solve: set[TypeVariable]
+    ) -> tuple[set[TypeConstraint], dict[TypeVariable, TypeVariable]]:
+        """
+        Filter out leaf type variables that only appear once in the constraints. These type variables are not
+        interesting and can be removed from the constraints.
+        """
+
+        sub_typevars = defaultdict(set)
+        tv_to_dtvs: dict[TypeVariable, set[TypeVariable | DerivedTypeVariable]] = defaultdict(set)
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                if isinstance(constraint.sub_type, TypeVariable):
+                    sub_typevars[constraint.sub_type].add(constraint.super_type)
+                for tv in [constraint.sub_type, constraint.super_type]:
+                    if isinstance(tv, DerivedTypeVariable):
+                        tv_to_dtvs[tv.type_var].add(constraint.sub_type)
+                    elif isinstance(tv, TypeVariable):
+                        tv_to_dtvs[tv].add(constraint.sub_type)
+
+        ub_subtypes: dict[TypeVariable, TypeVariable] = {}
+        for tv, dtvs in tv_to_dtvs.items():
+            if len(dtvs) == 1 and tv in sub_typevars and len(sub_typevars[tv]) == 1:
+                ub = next(iter(sub_typevars[tv]))
+                if ub in tvs_to_solve:
+                    ub_subtypes[tv] = ub
+
+        filtered_constraints = set()
+        for constraint in constraints:
+            if isinstance(constraint, Subtype) and constraint.sub_type in ub_subtypes:
+                continue
+            filtered_constraints.add(constraint)
+
+        return filtered_constraints, ub_subtypes
+
+    def _degrade_constraint_set(self, constraints: set[TypeConstraint]) -> set[TypeConstraint]:
+        """
+        Degrade the constraint set to a smaller set of constraints to speed up the DFA generation process.
+        """
+
+        tv_with_ls = defaultdict(set)  # tv_with_ls are type variables with Loads or Stores
+        graph = networkx.Graph()
+
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                if isinstance(constraint.sub_type, DerivedTypeVariable) and isinstance(
+                    constraint.sub_type.labels[0], (Load, Store)
+                ):
+                    tv_with_ls[constraint.sub_type.type_var].add(constraint.sub_type)
+                if type(constraint.sub_type) is TypeVariable and type(constraint.super_type) is TypeVariable:
+                    graph.add_edge(constraint.sub_type, constraint.super_type)
+
+        tv_to_degrade = set()
+        for tv, dtvs in tv_with_ls.items():
+            if len(dtvs) > 5:
+                # degrade all subtype relationships involving this type variable to equivalence
+                tv_to_degrade.add(tv)
+
+        replacements = {}
+        for components in networkx.connected_components(graph):
+            if len(components) == 1:
+                continue
+            if any(tv in tv_to_degrade for tv in components):
+                components_lst = sorted(components, key=str)
+                representative = components_lst[0]
+                for tv in components_lst[1:]:
+                    replacements[tv] = representative
+
+        degraded_constraints = self._rewrite_constraints_with_replacements(constraints, replacements)
+
+        # discover more equivalence relations
+        eq_constraints = self._discover_equivalence(degraded_constraints)
+        _l.debug("Discovered %d equivalence constraints from degraded constraints.", len(eq_constraints))
+        if eq_constraints:
+            degraded_constraints, eq_replacements = self._handle_equivalence(degraded_constraints | eq_constraints)
+            self._equivalence |= eq_replacements
+
+        # filter them
+        degraded_constraints = self._filter_constraints(degraded_constraints)
+
+        self._equivalence |= replacements
+        return degraded_constraints
 
     def _convert_arrays(self, constraints):
         for constraint in constraints:
@@ -860,7 +1062,7 @@ class SimpleSolver:
     @staticmethod
     def _generate_constraint_subset(
         constraints: set[TypeConstraint], typevars: set[TypeVariable]
-    ) -> set[TypeConstraint]:
+    ) -> tuple[set[TypeConstraint], set[TypeVariable]]:
         subset = set()
         related_typevars = set(typevars)
         while True:
@@ -890,7 +1092,7 @@ class SimpleSolver:
             if not new:
                 break
             subset |= new
-        return subset
+        return subset, related_typevars
 
     def _generate_constraint_graph(
         self, constraints: set[TypeConstraint], interesting_variables: set[DerivedTypeVariable]

angr/analyses/typehoon/typehoon.py

@@ -40,6 +40,7 @@ class Typehoon(Analysis):
         must_struct: set[TypeVariable] | None = None,
         stackvar_max_sizes: dict[TypeVariable, int] | None = None,
         stack_offset_tvs: dict[int, TypeVariable] | None = None,
+        constraint_set_degradation_threshold: int = 150,
     ):
         """
 
@@ -57,6 +58,7 @@ class Typehoon(Analysis):
         self._must_struct = must_struct
         self._stackvar_max_sizes = stackvar_max_sizes if stackvar_max_sizes is not None else {}
         self._stack_offset_tvs = stack_offset_tvs if stack_offset_tvs is not None else {}
+        self._constraint_set_degradation_threshold = constraint_set_degradation_threshold
 
         self.bits = self.project.arch.bits
         self.solution = None
@@ -193,7 +195,7 @@ class Typehoon(Analysis):
             self.simtypes_solution.update(self._ground_truth)
 
     @staticmethod
-    def _resolve_derived(tv):
+    def _resolve_derived(tv: TypeVariable | DerivedTypeVariable) -> TypeVariable:
         return tv.type_var if isinstance(tv, DerivedTypeVariable) else tv
 
     def _solve(self):
@@ -211,7 +213,13 @@ class Typehoon(Analysis):
                     if isinstance(constraint.super_type, TypeVariable):
                         typevars.add(self._resolve_derived(constraint.super_type))
 
-        solver = SimpleSolver(self.bits, self._constraints, typevars, stackvar_max_sizes=self._stackvar_max_sizes)
+        solver = SimpleSolver(
+            self.bits,
+            self._constraints,
+            typevars,
+            stackvar_max_sizes=self._stackvar_max_sizes,
+            constraint_set_degradation_threshold=self._constraint_set_degradation_threshold,
+        )
         self.solution = solver.solution
         self.processed_constraints_count = solver.processed_constraints_count
         self.eqclass_constraints_count = solver.eqclass_constraints_count

angr/analyses/variable_recovery/engine_ail.py

@@ -633,10 +633,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
         return RichR(r0.data << shiftamount, typevar=typeconsts.int_type(result_size), type_constraints=None)
@@ -651,10 +648,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -672,10 +666,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -691,10 +682,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -761,22 +749,22 @@ class SimEngineVRAIL(
     def _handle_binop_Rol(self, expr):
         arg0, arg1 = expr.operands
 
-        r0 = self._expr_bv(arg0)
+        _ = self._expr_bv(arg0)
         _ = self._expr_bv(arg1)
         result_size = arg0.bits
 
         r = self.state.top(result_size)
-        return RichR(r, typevar=r0.typevar)
+        return RichR(r)
 
     def _handle_binop_Ror(self, expr):
         arg0, arg1 = expr.operands
 
-        r0 = self._expr_bv(arg0)
+        _ = self._expr_bv(arg0)
         _ = self._expr_bv(arg1)
         result_size = arg0.bits
 
         r = self.state.top(result_size)
-        return RichR(r, typevar=r0.typevar)
+        return RichR(r)
 
     def _handle_binop_Concat(self, expr):
         arg0, arg1 = expr.operands

angr/state_plugins/unicorn_engine.py

@@ -394,14 +394,14 @@ class _VexArchInfo(ctypes.Structure):
 
 def _load_native():
     if sys.platform == "darwin":
-        libfile = "angr_native.dylib"
+        libfile = "unicornlib.dylib"
     elif sys.platform in {"win32", "cygwin"}:
-        libfile = "angr_native.dll"
+        libfile = "unicornlib.dll"
     else:
-        libfile = "angr_native.so"
+        libfile = "unicornlib.so"
 
     try:
-        angr_path = str(importlib.resources.files("angr") / "lib" / libfile)
+        angr_path = str(importlib.resources.files("angr") / libfile)
         h = ctypes.CDLL(angr_path)
 
         VexArch = ctypes.c_int

{angr-9.2.159.dist-info → angr-9.2.160.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.159
+Version: 9.2.160
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 License: BSD-2-Clause
 Project-URL: Homepage, https://angr.io/
 Project-URL: Repository, https://github.com/angr/angr
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
@@ -17,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.159
+Requires-Dist: archinfo==9.2.160
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.159
-Requires-Dist: cle==9.2.159
+Requires-Dist: claripy==9.2.160
+Requires-Dist: cle==9.2.160
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
 Requires-Dist: protobuf>=5.28.2
@@ -31,7 +30,7 @@ Requires-Dist: pycparser>=2.18
 Requires-Dist: pydemumble
 Requires-Dist: pyformlang
 Requires-Dist: pypcode<4.0,>=3.2.1
-Requires-Dist: pyvex==9.2.159
+Requires-Dist: pyvex==9.2.160
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.159.dist-info → angr-9.2.160.dist-info}/RECORD

@@ -1,4 +1,4 @@
-angr/__init__.py,sha256=OceCOkg7DfGXhezCu4vARQkwc1Vm6rKcmI5EUdsljpU,9153
+angr/__init__.py,sha256=y2AyYUWq5y7F77fLWaQlVLS_IfEoqKG_0JJn943Yb0g,9153
 angr/__main__.py,sha256=AK9V6uPZ58UuTKmmiH_Kgn5pG9AvjnmJCPOku69A-WU,4993
 angr/annocfg.py,sha256=0NIvcuCskwz45hbBzigUTAuCrYutjDMwEXtMJf0y0S0,10742
 angr/blade.py,sha256=NhesOPloKJC1DQJRv_HBT18X7oNxK16JwAfNz2Lc1o0,15384
@@ -14,7 +14,7 @@ angr/keyed_region.py,sha256=Cx6dadqFgEvRmEHTbCJpg9mXkBtKGc_BKckHc6bk1IU,17992
 angr/knowledge_base.py,sha256=hRoSLuLaOXmddTSF9FN5TVs7liftpBGq_IICz5AaYBk,4533
 angr/project.py,sha256=ANJUNPF41_Gs1vH8SC28FktgogurkNdeTH-uqLNPeoQ,37567
 angr/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-angr/rustylib.abi3.so,sha256=4BIY3LBXyNrKq6Lm6H4LQuIeBFg0MgPTf7OY-c3k3H0,4791920
+angr/rustylib.abi3.so,sha256=fFNRVo1fu9Boxtq1v4XeVgAlJyUTLSNhB8dNz23hKLg,4791920
 angr/serializable.py,sha256=l908phj_KcqopEEL_oCufbP_H6cm3Wc9v-5xdux1-6g,1533
 angr/sim_manager.py,sha256=w7yTfWR-P9yoN5x85eeiNpj9dTrnjpJ3o5aoFpDAPnc,39396
 angr/sim_options.py,sha256=tfl57MFECmA7uvMMtQrRRbpG8g_A9jKOzwY6nApTW6Y,17782
@@ -26,6 +26,7 @@ angr/sim_variable.py,sha256=3DssmMw5G7m_-MYToJ3LBP-ooy2UQEuI2YgxIuX3d4Y,13177
 angr/slicer.py,sha256=DND0BERanYKafasRH9MDFAng0rSjdjmzXj2-phCD6CQ,10634
 angr/state_hierarchy.py,sha256=qDQCUGXmQm3vOxE3CSoiqTH4OAFFOWZZt9BLhNpeOhA,8484
 angr/tablespecs.py,sha256=Kx1e87FxTx3_ZN7cAHWZSRpdInT4Vfj5gExAWtLkLTw,3259
+angr/unicornlib.dylib,sha256=aFP8fWKwgFSW-ULArLcXW8oj7TRGdOklXZSbzBMjZQQ,234064
 angr/vaults.py,sha256=D_gkDegCyPlZMKGC5E8zINYAaZfSXNWbmhX0rXCYpvM,9718
 angr/ailment/__init__.py,sha256=X1LTS6MuTovGtbXBjZendUVOzRk-ib-bP0imuqJDOYI,2039
 angr/ailment/block.py,sha256=rkmimsNPhrUabVVbRd2IgCaW0hA2_isvAsKlYtHZhgY,2428
@@ -120,11 +121,11 @@ angr/analyses/decompiler/block_io_finder.py,sha256=9J56W0_SQPczZ2-VoxqSv61T57foH
 angr/analyses/decompiler/block_similarity.py,sha256=S1lTlXFyOmJlQa7I3y7xgLsENLS4XGET7tdD55k_6Vg,6859
 angr/analyses/decompiler/block_simplifier.py,sha256=wjdp5fBMbAh6C3YKadQb56DP7jzuWq1bS7KJ1amah4g,14249
 angr/analyses/decompiler/callsite_maker.py,sha256=QxdNvnPt0oyRtsbFLCVpWdI7NL1LdT-TlEq27X5RAqA,23150
-angr/analyses/decompiler/clinic.py,sha256=BAPMXpIyhmY0IhlVfIXgjxArnAnux_BTJQ76RLbdwWc,150537
+angr/analyses/decompiler/clinic.py,sha256=wfUJO9BI0htA38x3HF_u1Uq9vch8vzMFXF2UzQ6btbE,150808
 angr/analyses/decompiler/condition_processor.py,sha256=r1lVXkFLai8DtU5gqtvxz3kpjW2S4oP4mNSx7iqzQ38,53175
 angr/analyses/decompiler/decompilation_cache.py,sha256=gAZtyXs-eoFj3680bTrJVAZcIoaPsFK0kayu30NYLb4,1509
 angr/analyses/decompiler/decompilation_options.py,sha256=NDB67DI1L-stvJ4b1eQkfV26HgDJ_rG9-6PEv08G9-8,8195
-angr/analyses/decompiler/decompiler.py,sha256=5olAxG6aDWiY-LtwCgXaWTajvfU7VsiNDtiNpJs37VY,30415
+angr/analyses/decompiler/decompiler.py,sha256=5_ifidQ9u5lUupyZD9AVHWmJCzviGsqrZhneZNv4dqw,30479
 angr/analyses/decompiler/empty_node_remover.py,sha256=4CdxTM1AVmRoEdRIwJg1YEy10AgkEoRmJ8SU7xGbKnM,7424
 angr/analyses/decompiler/expression_narrower.py,sha256=lBtcsPu4V5JJ_u25GF-BJ3vaybu8TRr9XxmnjOrA4J8,10367
 angr/analyses/decompiler/goto_manager.py,sha256=wVoeXJcadIda84LloGgqW-rL0QHLv3fx4vZHLhmz-_o,4027
@@ -376,10 +377,10 @@ angr/analyses/s_reaching_definitions/s_reaching_definitions.py,sha256=GkMe-Kl4zz
 angr/analyses/typehoon/__init__.py,sha256=KjKBUZadAd3grXUy48_qO0L4Me-riSqPGteVDcTL59M,92
 angr/analyses/typehoon/dfa.py,sha256=41lzhE-QmkC342SjfaaPI41lr4Au5XROTu_7oenvg7g,3823
 angr/analyses/typehoon/lifter.py,sha256=hxYJmM_A0Kl6YgY7NyWBtA3ieaY49Ey3ESCHC61lMys,4000
-angr/analyses/typehoon/simple_solver.py,sha256=FCXrUzN4FyLh9_WGj1n0GrFSGt9-kkE5qvk0YlfEf9A,58255
+angr/analyses/typehoon/simple_solver.py,sha256=CCGsuxzcRwPxh3S3fU_CJNQ7KVJaTP_SzH5ZImuPhDw,67609
 angr/analyses/typehoon/translator.py,sha256=_UE1JC4KNDXXl4plula9OApK1ee07z9BFdX9HKa5uqw,10568
 angr/analyses/typehoon/typeconsts.py,sha256=jQEVziyt3LnctrSrCtbUSPi-0tjl8DKoLMFfaOEG3lI,7939
-angr/analyses/typehoon/typehoon.py,sha256=_f8-l1XyxmQm3gvR6wO7q_PRhIVmYEX7dVDfy2kmgM4,12426
+angr/analyses/typehoon/typehoon.py,sha256=qj5MBJdzVB-5f73N_Da0gs5fG-eIFN272VNfsdYn7lo,12777
 angr/analyses/typehoon/typevars.py,sha256=ZDnKaGEwBTzYWUPQzacQkJ4rMpUDlnLzzJuKyQuEEtA,17839
 angr/analyses/typehoon/variance.py,sha256=3wYw3of8uoar-MQ7gD6arALiwlJRW990t0BUqMarXIY,193
 angr/analyses/unpacker/__init__.py,sha256=tBXwDMFKN0Hp8YP0DK-c6deo0Muc_LNopvoKKbzp3Tc,190
@@ -387,7 +388,7 @@ angr/analyses/unpacker/obfuscation_detector.py,sha256=VWMHOO2UbyiGzRYzAq9yrU3WwZ
 angr/analyses/unpacker/packing_detector.py,sha256=SO6aXR1gZkQ7w17AAv3C1-U2KAc0yL9OIQqjNOtVnuo,5331
 angr/analyses/variable_recovery/__init__.py,sha256=eA1SHzfSx8aPufUdkvgMmBnbI6VDYKKMJklcOoCO7Ao,208
 angr/analyses/variable_recovery/annotations.py,sha256=2va7cXnRHYqVqXeVt00QanxfAo3zanL4BkAcC0-Bk20,1438
-angr/analyses/variable_recovery/engine_ail.py,sha256=M8nEWRb0_N_id9KMFDTL6P_MuXNR_rknwcHVrxkvDbU,34019
+angr/analyses/variable_recovery/engine_ail.py,sha256=8yqrl_qfO_DCvaIxwsa_eits5rIbly4rBEFh5W_U2O4,33709
 angr/analyses/variable_recovery/engine_base.py,sha256=uKtxlkGVWQC1ACAA9-9e2T5TriwD0bhOY-N4IRakCJc,52641
 angr/analyses/variable_recovery/engine_vex.py,sha256=5Q2S1jAr7tALa0m0okqBHBe3cUePmJlnV1Grxos1xbo,21344
 angr/analyses/variable_recovery/irsb_scanner.py,sha256=1dL2IC7fZGuRrhmcpa2Q-G666aMPmbM8zSzmIRpLNSY,5141
@@ -586,7 +587,6 @@ angr/knowledge_plugins/xrefs/__init__.py,sha256=5PhqVOtTZ27lCjJ9wp7akUeJydqILbyC
 angr/knowledge_plugins/xrefs/xref.py,sha256=U2H1rfffp5EXoh0awlGxMBxA4K5MIwl3CXjV3Uih3tA,4856
 angr/knowledge_plugins/xrefs/xref_manager.py,sha256=1n373rtV91xicAfSUresRigsZ6qCBhPOaJKrN_SW3QY,4157
 angr/knowledge_plugins/xrefs/xref_types.py,sha256=LcQ9pD4E4XlC51Us49xiqAoGAFGpnCrpYO4mOzILiKI,308
-angr/lib/angr_native.dylib,sha256=cDRLLQ2szE6ISI2oUBH2nP8ThwYPIHD8K5tSK5Jxy1Y,234064
 angr/misc/__init__.py,sha256=FoUwjk1DhqlIsr2sBN0MlR8MnSOGQv9QJhxmq32RYuA,355
 angr/misc/ansi.py,sha256=nPJHC0SKfqasMQZ0LxdmmIYojjmk4nr5jI6FrzoTwS0,811
 angr/misc/autoimport.py,sha256=iZagpuPwZWczUTYIqs-JkDMQjftMqc_cchcm7OBFiEg,3450
@@ -1308,7 +1308,7 @@ angr/state_plugins/solver.py,sha256=GVN-z84AkVtWbTt-6m8j_1pxxDQ-Y2GsnebdLVF4Wmk,
 angr/state_plugins/symbolizer.py,sha256=XEdY9g1G0xN0SbA1MDmSDsaOithnP3HnrsckeNV37m4,11011
 angr/state_plugins/trace_additions.py,sha256=d1P4a-DdC0c2Fu5_KAhNzfLr1mylAR2wWSOMSwad7os,29717
 angr/state_plugins/uc_manager.py,sha256=-mervKrD5a5K71CVAUxHrDW5RCduNwNxZXwW63L9bEA,2973
-angr/state_plugins/unicorn_engine.py,sha256=gvepo_hpUjrreGj0U6vgqnoQdGSSPVqvGdVnHG-Lgpc,77945
+angr/state_plugins/unicorn_engine.py,sha256=-HYSPKLxN1VEA6LeVXtHSyIVKEH-rY0pmNaRrYx9d4A,77934
 angr/state_plugins/view.py,sha256=968XQAnGrPB0gHh0f6DDTEn54VlpwFjcDZgtAmIwCf8,12382
 angr/state_plugins/heap/__init__.py,sha256=ajfNPVloK8CUpfd1z22v8dof55c8skshy8aFHG-aqy8,340
 angr/state_plugins/heap/heap_base.py,sha256=IaKFHqGoWIcFWx6WCEvpnUvn8eqmD1Gay3JWFerLnnk,6281
@@ -1397,9 +1397,9 @@ angr/utils/types.py,sha256=688trvR0_j93sfeRgFT1npcmjNGSx99m_IPe9Xyy9WY,4967
 angr/utils/ssa/__init__.py,sha256=veiW783pfwUhphLOIgxBbiH6kL2i22daZQ2beJC5ZHs,15255
 angr/utils/ssa/tmp_uses_collector.py,sha256=digAUQpYoFR1VYfwoXlF3T1pYdDi6Pdq_ck54SjMabQ,813
 angr/utils/ssa/vvar_uses_collector.py,sha256=HewqUQluNE9EsaiLeFo7LaBvws_DDBDYNt9RBExy464,1367
-angr-9.2.159.dist-info/licenses/LICENSE,sha256=PmWf0IlSz6Jjp9n7nyyBQA79Q5C2ma68LRykY1V3GF0,1456
-angr-9.2.159.dist-info/METADATA,sha256=DK9INGhwh64jkzr6Q4XY0bW88b6mnEeFt9-IkNkFy6Q,4394
-angr-9.2.159.dist-info/WHEEL,sha256=Xo4I_AKyna1Fzpk3lt1KsHk3bISzty9j2i4Mgn1zPIM,108
-angr-9.2.159.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
-angr-9.2.159.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
-angr-9.2.159.dist-info/RECORD,,
+angr-9.2.160.dist-info/licenses/LICENSE,sha256=PmWf0IlSz6Jjp9n7nyyBQA79Q5C2ma68LRykY1V3GF0,1456
+angr-9.2.160.dist-info/METADATA,sha256=5PNZ_AfJn_ihj55HU-z9J2PzJpTkXem-HYY9lBXOT-c,4343
+angr-9.2.160.dist-info/WHEEL,sha256=Xo4I_AKyna1Fzpk3lt1KsHk3bISzty9j2i4Mgn1zPIM,108
+angr-9.2.160.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
+angr-9.2.160.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
+angr-9.2.160.dist-info/RECORD,,