angr 9.2.120__py3-none-win_amd64.whl → 9.2.121__py3-none-win_amd64.whl

angr/__init__.py

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

angr/analyses/cfg/cfg_fast.py

@@ -4131,7 +4131,8 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         if self.project.arch.name in {"MIPS64", "MIPS32"} or is_arm_arch(self.project.arch):
             self._ro_region_cdata_cache = []
             for segment in self.project.loader.main_object.segments:
-                if segment.is_readable and not segment.is_writable:
+                if segment.is_readable and segment.memsize >= 8:
+                    # the gp area is sometimes writable, so we can't test for (not segment.is_writable)
                     content = self.project.loader.memory.load(segment.vaddr, segment.memsize)
                     content_buf = pyvex.ffi.from_buffer(content)
                     self._ro_region_cdata_cache.append(content_buf)

angr/analyses/cfg/indirect_jump_resolvers/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from .mips_elf_fast import MipsElfFastResolver
+from .mips_elf_got import MipsElfGotResolver
 from .x86_elf_pic_plt import X86ElfPicPltResolver
 from .jumptable import JumpTableResolver
 from .x86_pe_iat import X86PeIatResolver
@@ -12,6 +13,7 @@ from .amd64_pe_iat import AMD64PeIatResolver
 
 __all__ = (
     "MipsElfFastResolver",
+    "MipsElfGotResolver",
     "X86ElfPicPltResolver",
     "JumpTableResolver",
     "X86PeIatResolver",

angr/analyses/cfg/indirect_jump_resolvers/default_resolvers.py

@@ -9,6 +9,7 @@ from . import AMD64ElfGotResolver
 from . import ConstantResolver
 from . import ArmElfFastResolver
 from . import AMD64PeIatResolver
+from . import MipsElfGotResolver
 
 DEFAULT_RESOLVERS = {
     "X86": {
@@ -29,6 +30,7 @@ DEFAULT_RESOLVERS = {
     },
     "MIPS32": {
         cle.MetaELF: [
+            MipsElfGotResolver,
             MipsElfFastResolver,
         ],
     },

angr/analyses/cfg/indirect_jump_resolvers/jumptable.py

@@ -1723,21 +1723,25 @@ class JumpTableResolver(IndirectJumpResolver):
         all_targets = []
         jump_table = []
 
-        try:
-            jumptable_si = claripy.SI(bits=project.arch.bits, to_conv=jumptable_addr)
-        except claripy.errors.BackendError:
-            return None
+        if jumptable_addr.op == "BVV":
+            stride = 0
+        else:
+            try:
+                jumptable_si = claripy.backends.vsa.simplify(jumptable_addr)
+                si_annotation = jumptable_si.get_annotation(claripy.annotation.StridedIntervalAnnotation)
+                stride = si_annotation.stride if si_annotation is not None else 0
+            except claripy.errors.BackendError:
+                return None
 
         # we may resolve a vtable (in C, e.g., the IO_JUMPS_FUNC in libc), but the stride of this load is usually 1
         # while the read statement reads a word size at a time.
         # we use this to differentiate between traditional jump tables (where each entry is some blocks that belong to
         # the current function) and vtables (where each entry is a function).
-        if jumptable_si.args[3] < load_size:  # stride < load_size
+        if stride < load_size:
             stride = load_size
             total_cases = jumptable_addr.cardinality // load_size
             sort = "vtable"  # it's probably a vtable!
         else:
-            stride = jumptable_si.args[3]
             total_cases = jumptable_addr.cardinality
             sort = "jumptable"