angr 9.2.131__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

angr/analyses/typehoon/simple_solver.py

@@ -123,12 +123,12 @@ class SketchNode(SketchNodeBase):
     Represents a node in a sketch graph.
     """
 
-    __slots__ = ("typevar", "upper_bound", "lower_bound")
+    __slots__ = ("lower_bound", "typevar", "upper_bound")
 
     def __init__(self, typevar: TypeVariable | DerivedTypeVariable):
         self.typevar: TypeVariable | DerivedTypeVariable = typevar
-        self.upper_bound = TopType()
-        self.lower_bound = BottomType()
+        self.upper_bound: TypeConstant = TopType()
+        self.lower_bound: TypeConstant = BottomType()
 
     def __repr__(self):
         return f"{self.lower_bound} <: {self.typevar} <: {self.upper_bound}"
@@ -164,8 +164,8 @@ class Sketch:
 
     __slots__ = (
         "graph",
-        "root",
         "node_mapping",
+        "root",
         "solver",
     )
 
@@ -202,7 +202,7 @@ class Sketch:
                     node = self.lookup(node.target)
         return node
 
-    def add_edge(self, src: SketchNodeBase, dst: SketchNodeBase, label):
+    def add_edge(self, src: SketchNodeBase, dst: SketchNodeBase, label) -> None:
         self.graph.add_edge(src, dst, label=label)
 
     def add_constraint(self, constraint: TypeConstraint) -> None:
@@ -214,13 +214,15 @@ class Sketch:
         if SimpleSolver._typevar_inside_set(subtype, PRIMITIVE_TYPES) and not SimpleSolver._typevar_inside_set(
             supertype, PRIMITIVE_TYPES
         ):
-            super_node: SketchNode | None = self.lookup(supertype)
+            super_node = self.lookup(supertype)
+            assert super_node is None or isinstance(super_node, SketchNode)
             if super_node is not None:
                 super_node.lower_bound = self.solver.join(super_node.lower_bound, subtype)
         elif SimpleSolver._typevar_inside_set(supertype, PRIMITIVE_TYPES) and not SimpleSolver._typevar_inside_set(
             subtype, PRIMITIVE_TYPES
         ):
-            sub_node: SketchNode | None = self.lookup(subtype)
+            sub_node = self.lookup(subtype)
+            assert sub_node is None or isinstance(sub_node, SketchNode)
             # assert sub_node is not None
             if sub_node is not None:
                 sub_node.upper_bound = self.solver.meet(sub_node.upper_bound, supertype)
@@ -261,7 +263,7 @@ class FORGOTTEN(enum.Enum):
 
 
 class ConstraintGraphNode:
-    __slots__ = ("typevar", "variance", "tag", "forgotten")
+    __slots__ = ("forgotten", "tag", "typevar", "variance")
 
     def __init__(
         self,
@@ -365,7 +367,7 @@ class SimpleSolver:
 
     def __init__(self, bits: int, constraints, typevars):
         if bits not in (32, 64):
-            raise ValueError("Pointer size %d is not supported. Expect 32 or 64." % bits)
+            raise ValueError(f"Pointer size {bits} is not supported. Expect 32 or 64.")
 
         self.bits = bits
         self._constraints: dict[TypeVariable, set[TypeConstraint]] = constraints
@@ -625,10 +627,8 @@ class SimpleSolver:
             for _, dst0, data0 in graph.out_edges(cls0, data=True):
                 if "label" in data0 and data0["label"] is not None:
                     for _, dst1, data1 in graph.out_edges(cls1, data=True):
-                        if (
-                            data0["label"] == data1["label"]
-                            or isinstance(data0["label"], Load)
-                            and isinstance(data1["label"], Store)
+                        if data0["label"] == data1["label"] or (
+                            isinstance(data0["label"], Load) and isinstance(data1["label"], Store)
                         ):
                             SimpleSolver._unify(
                                 equivalence_classes, equivalence_classes[dst0], equivalence_classes[dst1], graph
@@ -1278,4 +1278,4 @@ class SimpleSolver:
             return Pointer32
         if self.bits == 64:
             return Pointer64
-        raise NotImplementedError("Unsupported bits %d" % self.bits)
+        raise NotImplementedError(f"Unsupported bits {self.bits}")

angr/analyses/typehoon/translator.py

@@ -42,7 +42,7 @@ class TypeTranslator:
     #
 
     def struct_name(self):
-        return "struct_%d" % next(self._struct_ctr)
+        return f"struct_{next(self._struct_ctr)}"
 
     #
     # Type translation
@@ -151,6 +151,9 @@ class TypeTranslator:
     def _translate_Int256(self, tc):  # pylint:disable=unused-argument
         return sim_type.SimTypeInt256(signed=False).with_arch(self.arch)
 
+    def _translate_Int512(self, tc):  # pylint:disable=unused-argument
+        return sim_type.SimTypeInt512(signed=False).with_arch(self.arch)
+
     def _translate_TypeVariableReference(self, tc):
         if tc.typevar in self.translated:
             return self.translated[tc.typevar]
@@ -190,6 +193,9 @@ class TypeTranslator:
     def _translate_SimTypeInt256(self, st: sim_type.SimTypeChar) -> typeconsts.Int256:
         return typeconsts.Int256()
 
+    def _translate_SimTypeInt512(self, st: sim_type.SimTypeChar) -> typeconsts.Int512:
+        return typeconsts.Int512()
+
     def _translate_SimTypeInt(self, st: sim_type.SimTypeInt) -> typeconsts.Int32:
         return typeconsts.Int32()
 
@@ -221,7 +227,7 @@ class TypeTranslator:
             return typeconsts.Pointer32(base)
         if self.arch.bits == 64:
             return typeconsts.Pointer64(base)
-        raise TypeError("Unsupported pointer size %d" % self.arch.bits)
+        raise TypeError(f"Unsupported pointer size {self.arch.bits}")
 
 
 TypeConstHandlers = {
@@ -235,6 +241,7 @@ TypeConstHandlers = {
     typeconsts.Int64: TypeTranslator._translate_Int64,
     typeconsts.Int128: TypeTranslator._translate_Int128,
     typeconsts.Int256: TypeTranslator._translate_Int256,
+    typeconsts.Int512: TypeTranslator._translate_Int512,
     typeconsts.TypeVariableReference: TypeTranslator._translate_TypeVariableReference,
 }
 
@@ -247,6 +254,7 @@ SimTypeHandlers = {
     sim_type.SimTypeChar: TypeTranslator._translate_SimTypeChar,
     sim_type.SimTypeInt128: TypeTranslator._translate_SimTypeInt128,
     sim_type.SimTypeInt256: TypeTranslator._translate_SimTypeInt256,
+    sim_type.SimTypeInt512: TypeTranslator._translate_SimTypeInt512,
     sim_type.SimStruct: TypeTranslator._translate_SimStruct,
     sim_type.SimTypeArray: TypeTranslator._translate_SimTypeArray,
 }

angr/analyses/typehoon/typeconsts.py

@@ -107,6 +107,13 @@ class Int256(Int):
         return "int256"
 
 
+class Int512(Int):
+    SIZE = 32
+
+    def __repr__(self, memo=None):
+        return "int512"
+
+
 class FloatBase(TypeConstant):
     def __repr__(self, memo=None):
         return "floatbase"
@@ -182,7 +189,7 @@ class Array(TypeConstant):
     def __repr__(self, memo=None):
         if self.count is None:
             return f"{self.element!r}[?]"
-        return "%r[%d]" % (self.element, self.count)
+        return f"{self.element!r}[{self.count}]"
 
     def __eq__(self, other):
         return type(other) is type(self) and self.element == other.element and self.count == other.count
@@ -281,7 +288,7 @@ class TypeVariableReference(TypeConstant):
 #
 
 
-def int_type(bits: int) -> Int | None:
+def int_type(bits: int) -> Int:
     mapping = {
         1: Int1,
         8: Int8,
@@ -290,10 +297,11 @@ def int_type(bits: int) -> Int | None:
         64: Int64,
         128: Int128,
         256: Int256,
+        512: Int512,
     }
     if bits in mapping:
         return mapping[bits]()
-    return None
+    raise TypeError(f"Not a known size of int: {bits}")
 
 
 def float_type(bits: int) -> FloatBase | None:

angr/analyses/typehoon/typevars.py

@@ -26,9 +26,9 @@ class TypeConstraint:
 
 class Equivalence(TypeConstraint):
     __slots__ = (
+        "_cached_hash",
         "type_a",
         "type_b",
-        "_cached_hash",
     )
 
     def __init__(self, type_a, type_b):
@@ -44,10 +44,8 @@ class Equivalence(TypeConstraint):
 
     def __eq__(self, other):
         return type(other) is Equivalence and (
-            self.type_a == other.type_a
-            and self.type_b == other.type_b
-            or self.type_b == other.type_a
-            and self.type_a == other.type_b
+            (self.type_a == other.type_a and self.type_b == other.type_b)
+            or (self.type_b == other.type_a and self.type_a == other.type_b)
         )
 
     def __hash__(self):
@@ -55,7 +53,7 @@ class Equivalence(TypeConstraint):
 
 
 class Existence(TypeConstraint):
-    __slots__ = ("type_", "_cached_hash")
+    __slots__ = ("_cached_hash", "type_")
 
     def __init__(self, type_):
         self.type_ = type_
@@ -85,9 +83,9 @@ class Existence(TypeConstraint):
 
 class Subtype(TypeConstraint):
     __slots__ = (
-        "super_type",
-        "sub_type",
         "_cached_hash",
+        "sub_type",
+        "super_type",
     )
 
     def __init__(self, sub_type: TypeType, super_type: TypeType):
@@ -141,10 +139,10 @@ class Add(TypeConstraint):
     """
 
     __slots__ = (
+        "_cached_hash",
         "type_0",
         "type_1",
         "type_r",
-        "_cached_hash",
     )
 
     def __init__(self, type_0, type_1, type_r):
@@ -210,10 +208,10 @@ class Sub(TypeConstraint):
     """
 
     __slots__ = (
+        "_cached_hash",
         "type_0",
         "type_1",
         "type_r",
-        "_cached_hash",
     )
 
     def __init__(self, type_0, type_1, type_r):
@@ -277,7 +275,7 @@ _typevariable_counter = count()
 
 
 class TypeVariable:
-    __slots__ = ("idx", "name", "_cached_hash")
+    __slots__ = ("_cached_hash", "idx", "name")
 
     def __init__(self, idx: int | None = None, name: str | None = None):
         if idx is None:
@@ -310,18 +308,18 @@ class TypeVariable:
     def __repr__(self):
         if self.name:
             return f"{self.name}|tv_{self.idx:02d}"
-        return "tv_%02d" % self.idx
+        return f"tv_{self.idx:02d}"
 
 
 class DerivedTypeVariable(TypeVariable):
-    __slots__ = ("type_var", "labels")
+    __slots__ = ("labels", "type_var")
 
-    type_var: TypeVariable | TypeConstant
+    labels: tuple[BaseLabel, ...]
 
     def __init__(
         self,
-        type_var: TypeVariable | DerivedTypeVariable | None,
-        label,
+        type_var: TypeType,
+        label: BaseLabel | None,
         labels: Iterable[BaseLabel] | None = None,
         idx=None,
     ):
@@ -339,8 +337,10 @@ class DerivedTypeVariable(TypeVariable):
 
         if label is not None:
             self.labels = (*existing_labels, label)
+        elif labels is not None:
+            self.labels = existing_labels + tuple(labels)
         else:
-            self.labels: tuple[BaseLabel] = existing_labels + tuple(labels)
+            self.labels = existing_labels
 
         if not self.labels:
             raise ValueError("A DerivedTypeVariable must have at least one label")
@@ -350,10 +350,10 @@ class DerivedTypeVariable(TypeVariable):
     def one_label(self) -> BaseLabel | None:
         return self.labels[0] if len(self.labels) == 1 else None
 
-    def path(self) -> tuple[BaseLabel]:
+    def path(self) -> tuple[BaseLabel, ...]:
         return self.labels
 
-    def longest_prefix(self) -> TypeVariable | DerivedTypeVariable | None:
+    def longest_prefix(self) -> TypeType | None:
         if not self.labels:
             return None
         if len(self.labels) == 1:
@@ -396,8 +396,8 @@ class DerivedTypeVariable(TypeVariable):
 
 class TypeVariables:
     __slots__ = (
-        "_typevars",
         "_last_typevars",
+        "_typevars",
     )
 
     def __init__(self):
@@ -416,9 +416,9 @@ class TypeVariables:
         #    sum(len(v) for v in self._typevars.items()),
         #    len(self._typevars),
         # )
-        return "{TypeVars: %d items}" % len(self._typevars)
+        return f"{{TypeVars: {len(self._typevars)} items}}"
 
-    def add_type_variable(self, var: SimVariable, codeloc, typevar: TypeVariable):  # pylint:disable=unused-argument
+    def add_type_variable(self, var: SimVariable, codeloc, typevar: TypeType):  # pylint:disable=unused-argument
         if var not in self._typevars:
             self._typevars[var] = set()
         elif typevar in self._typevars[var]:
@@ -512,7 +512,7 @@ class AddN(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "+%d" % self.n
+        return f"+{self.n}"
 
 
 class SubN(BaseLabel):
@@ -523,7 +523,7 @@ class SubN(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "-%d" % self.n
+        return f"-{self.n}"
 
 
 class ConvertTo(BaseLabel):
@@ -534,13 +534,13 @@ class ConvertTo(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "conv(%d)" % self.to_bits
+        return f"conv({self.to_bits})"
 
 
 class ReinterpretAs(BaseLabel):
     __slots__ = (
-        "to_type",
         "to_bits",
+        "to_type",
     )
 
     def __init__(self, to_type, to_bits):

angr/analyses/unpacker/__init__.py

@@ -3,4 +3,4 @@ from .packing_detector import PackingDetector
 from .obfuscation_detector import ObfuscationDetector
 
 
-__all__ = ("PackingDetector", "ObfuscationDetector")
+__all__ = ("ObfuscationDetector", "PackingDetector")