angr 9.2.167__tar.gz → 9.2.169__tar.gz

{angr-9.2.167 → angr-9.2.169}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.167
+Version: 9.2.169
 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/
@@ -16,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.167
+Requires-Dist: archinfo==9.2.169
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.167
-Requires-Dist: cle==9.2.167
+Requires-Dist: claripy==9.2.169
+Requires-Dist: cle==9.2.169
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
 Requires-Dist: protobuf>=5.28.2
@@ -30,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.167
+Requires-Dist: pyvex==9.2.169
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.167 → angr-9.2.169}/angr/__init__.py

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

{angr-9.2.167 → angr-9.2.169}/angr/analyses/cfg/cfb.py

@@ -119,19 +119,19 @@ class CFBlanket(Analysis):
     def _init_regions(self):
         for obj in self.project.loader.all_objects:
             if isinstance(obj, cle.MetaELF):
-                if obj.sections:
+                if obj.segments:
+                    if "segment" not in self._exclude_region_types:
+                        for segment in obj.segments:
+                            if segment.memsize > 0:
+                                mr = MemoryRegion(segment.vaddr, segment.memsize, "segment", obj, segment)
+                                self._regions.append(mr)
+                elif obj.sections:
                     if "section" not in self._exclude_region_types:
                         # Enumerate sections in an ELF file
                         for section in obj.sections:
                             if section.occupies_memory:
                                 mr = MemoryRegion(section.vaddr, section.memsize, "section", obj, section)
                                 self._regions.append(mr)
-                elif obj.segments:
-                    if "segment" not in self._exclude_region_types:
-                        for segment in obj.segments:
-                            if segment.memsize > 0:
-                                mr = MemoryRegion(segment.vaddr, segment.memsize, "segment", obj, segment)
-                                self._regions.append(mr)
                 else:
                     raise NotImplementedError(
                         "Currently ELFs without sections or segments are not supported. Please "

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/clinic.py

@@ -55,6 +55,7 @@ from .optimization_passes import (
 
 if TYPE_CHECKING:
     from angr.knowledge_plugins.cfg import CFGModel
+    from .notes import DecompilationNote
     from .decompilation_cache import DecompilationCache
     from .peephole_optimizations import PeepholeOptimizationStmtBase, PeepholeOptimizationExprBase
 
@@ -149,6 +150,7 @@ class Clinic(Analysis):
         ail_graph: networkx.DiGraph | None = None,
         arg_vvars: dict[int, tuple[ailment.Expr.VirtualVariable, SimVariable]] | None = None,
         start_stage: ClinicStage | None = ClinicStage.INITIALIZATION,
+        notes: dict[str, DecompilationNote] | None = None,
     ):
         if not func.normalized and mode == ClinicMode.DECOMPILE:
             raise ValueError("Decompilation must work on normalized function graphs.")
@@ -194,6 +196,8 @@ class Clinic(Analysis):
         # actual stack variables. these secondary stack variables can be safely eliminated if not used by anything.
         self.secondary_stackvars: set[int] = set()
 
+        self.notes = notes if notes is not None else {}
+
         #
         # intermediate variables used during decompilation
         #
@@ -1555,6 +1559,7 @@ class Clinic(Analysis):
                 refine_loops_with_single_successor=self._refine_loops_with_single_successor,
                 complete_successors=self._complete_successors,
                 stack_pointer_tracker=stack_pointer_tracker,
+                notes=self.notes,
                 **kwargs,
             )
             if a.out_graph:

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/decompilation_cache.py

@@ -22,6 +22,7 @@ class DecompilationCache:
         "errors",
         "func_typevar",
         "ite_exprs",
+        "notes",
         "parameters",
         "type_constraints",
         "var_to_typevar",
@@ -38,6 +39,7 @@ class DecompilationCache:
         self.ite_exprs: set[tuple[int, Any]] | None = None
         self.binop_operators: dict[OpDescriptor, str] | None = None
         self.errors: list[str] = []
+        self.notes: dict[str, str] = {}
 
     @property
     def local_types(self):

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/decompilation_options.py

@@ -239,6 +239,16 @@ options = [
         default_value=False,
         clears_cache=True,
     ),
+    O(
+        "Display decompilation notes as comments",
+        "Display decompilation notes in the outpu as function comments.",
+        bool,
+        "codegen",
+        "display_notes",
+        category="Display",
+        default_value=False,
+        clears_cache=False,
+    ),
     O(
         "Multi-expression statements generation",
         "Should the structuring algorithm generate multi-expression statements? If so, under what conditions?",

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/decompiler.py

@@ -21,12 +21,13 @@ from .region_identifier import RegionIdentifier
 from .optimization_passes.optimization_pass import OptimizationPassStage
 from .ailgraph_walker import AILGraphWalker
 from .condition_processor import ConditionProcessor
-from .decompilation_options import DecompilationOption
+from .decompilation_options import DecompilationOption, PARAM_TO_OPTION
 from .decompilation_cache import DecompilationCache
 from .utils import remove_edges_in_ailgraph
 from .sequence_walker import SequenceWalker
 from .structuring.structurer_nodes import SequenceNode
 from .presets import DECOMPILATION_PRESETS, DecompilationPreset
+from .notes import DecompilationNote
 
 if TYPE_CHECKING:
     from angr.knowledge_plugins.cfg.cfg_model import CFGModel
@@ -80,7 +81,7 @@ class Decompiler(Analysis):
             func = self.kb.functions[func]
         self.func: Function = func
         self._cfg = cfg.model if isinstance(cfg, CFGFast) else cfg
-        self._options = options or []
+        self._options = self._parse_options(options) if options else []
 
         if preset is None and optimization_passes:
             self._optimization_passes = optimization_passes
@@ -145,6 +146,7 @@ class Decompiler(Analysis):
         self._copied_var_ids: set[int] = set()
         self._optimization_scratch: dict[str, Any] = {}
         self.expr_collapse_depth = expr_collapse_depth
+        self.notes: dict[str, DecompilationNote] = {}
 
         if decompile:
             with self._resilience():
@@ -171,6 +173,20 @@ class Decompiler(Analysis):
         id_checks = {"cfg", "variable_kb"}
         return all(a[k] is b[k] if k in id_checks else a[k] == b[k] for k in self._cache_parameters)
 
+    @staticmethod
+    def _parse_options(options: list[tuple[DecompilationOption | str, Any]]) -> list[tuple[DecompilationOption, Any]]:
+        """
+        Parse the options and return a list of option tuples.
+        """
+
+        converted_options = []
+        for o, v in options:
+            if isinstance(o, str):
+                # convert to DecompilationOption
+                o = PARAM_TO_OPTION[o]
+            converted_options.append((o, v))
+        return converted_options
+
     @timethis
     def _decompile(self):
         if self.func.is_simprocedure:
@@ -268,6 +284,7 @@ class Decompiler(Analysis):
                 ail_graph=self._clinic_graph,
                 arg_vvars=self._clinic_arg_vvars,
                 start_stage=self._clinic_start_stage,
+                notes=self.notes,
                 **self.options_to_params(self.options_by_class["clinic"]),
             )
         else:
@@ -378,6 +395,7 @@ class Decompiler(Analysis):
                 const_formats=old_codegen.const_formats if old_codegen is not None else None,
                 externs=clinic.externs,
                 binop_depth_cutoff=self.expr_collapse_depth,
+                notes=self.notes,
                 **self.options_to_params(self.options_by_class["codegen"]),
             )
 

angr-9.2.169/angr/analyses/decompiler/notes/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from .decompilation_note import DecompilationNote, DecompilationNoteLevel
+
+
+__all__ = (
+    "DecompilationNote",
+    "DecompilationNoteLevel",
+)

angr-9.2.169/angr/analyses/decompiler/notes/decompilation_note.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import Any
+
+from enum import Enum
+
+
+class DecompilationNoteLevel(Enum):
+    """
+    Enum class describing the level of each decompilation note.
+    """
+
+    DEBUG = 0
+    INFO = 1
+    WARNING = 2
+    CRITICAL = 3
+
+
+class DecompilationNote:
+    """
+    Describes a note that is generated during decompilation.
+
+    Key is a unique string for the decompilation note. It is used as an index in the decompilation notes dictionary in
+    the Decompiler class.
+    Name is string for display by default.
+    Content is the actual content of the note. It can be of any time, but for custom types, you must override `__str__`
+    so that it can be displayed.
+    Level is the level of the note. The following values are available: DecompilationNoteLevel.DEBUG,
+    DecompilationNoteLevel.INFO, DecompilationNoteLevel.WARNING, and DecompilationNoteLevel.CRITICAL.
+    """
+
+    __slots__ = (
+        "content",
+        "key",
+        "level",
+        "name",
+    )
+
+    def __init__(self, key: str, name: str, content: Any, *, level=DecompilationNoteLevel.INFO):
+        self.key = key
+        self.name = name
+        self.content = content
+        self.level = level
+
+    def __repr__(self):
+        return f"<DecompilationNote: {self.name}>"
+
+    def __str__(self):
+        return f"{self.name}: {self.content}"

angr-9.2.169/angr/analyses/decompiler/notes/deobfuscated_strings.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from .decompilation_note import DecompilationNote
+
+
+class DeobfuscatedString:
+    """
+    Represents a deobfuscated string.
+    """
+
+    __slots__ = ("ref_addr", "type", "value")
+
+    def __init__(self, value: bytes, obf_type: str, ref_addr: int | None = None):
+        self.value = value
+        self.type = obf_type
+        self.ref_addr = ref_addr
+
+    def __repr__(self):
+        return (
+            f"<DeobfuscatedString Type{self.type} value={self.value!r} ref={self.ref_addr:#x}>"
+            if self.ref_addr is not None
+            else f"<DeobfuscatedString Type{self.type} value={self.value!r}>"
+        )
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class DeobfuscatedStringsNote(DecompilationNote):
+    """
+    Represents a decompilation note that describes obfuscated strings found during decompilation.
+    """
+
+    def __init__(self, key: str = "deobfuscated_strings", name: str = "Deobfuscated Strings"):
+        super().__init__(key, name, None)
+
+        self.strings: dict[int, DeobfuscatedString] = {}
+
+    def add_string(self, obf_type: str, value: bytes, *, ref_addr: int):
+        """
+        Add a deobfuscated string to the note.
+
+        :param obf_type: The type of obfuscation (e.g., "1", "2").
+        :param value: The deobfuscated string value.
+        :param ref_addr: The address where this string is referenced, if applicable.
+        """
+        deobf_str = DeobfuscatedString(value, obf_type, ref_addr=ref_addr)
+        self.strings[ref_addr] = deobf_str
+
+    def __str__(self):
+        lines = ["Obfuscated strings are found in decompilation and have been deobfuscated:"]
+        for addr in sorted(self.strings):
+            deobf_str = self.strings[addr]
+            lines.append(f"  Type {deobf_str.type} @ {deobf_str.ref_addr:#x}: {deobf_str.value!r}")
+
+        return "\n".join(lines)

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/optimization_passes/optimization_pass.py

@@ -141,6 +141,7 @@ class OptimizationPass(BaseOptimizationPass):
         arg_vvars: set[int] | None = None,
         peephole_optimizations=None,
         stack_pointer_tracker=None,
+        notes: dict | None = None,
         **kwargs,
     ):
         super().__init__(func)
@@ -164,6 +165,7 @@ class OptimizationPass(BaseOptimizationPass):
         self._avoid_vvar_ids = avoid_vvar_ids or set()
         self._peephole_optimizations = peephole_optimizations
         self._stack_pointer_tracker = stack_pointer_tracker
+        self.notes = notes if notes is not None else {}
 
         # output
         self.out_graph: networkx.DiGraph | None = None

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/structured_codegen/base.py

@@ -1,3 +1,4 @@
+# pylint:disable=missing-class-docstring
 from __future__ import annotations
 from sortedcontainers import SortedDict
 
@@ -114,13 +115,45 @@ class InstructionMapping:
 
 
 class BaseStructuredCodeGenerator:
-    def __init__(self, flavor=None):
+    def __init__(self, flavor=None, notes=None):
         self.flavor = flavor
         self.text = None
         self.map_pos_to_node = None
         self.map_pos_to_addr = None
         self.map_addr_to_pos = None
         self.map_ast_to_pos: dict[SimVariable, set[PositionMappingElement]] | None = None
+        self.notes = notes if notes is not None else {}
+
+    def adjust_mapping_positions(
+        self,
+        offset: int,
+        pos_to_node: PositionMapping,
+        pos_to_addr: PositionMapping,
+        addr_to_pos: InstructionMapping,
+    ) -> tuple[PositionMapping, PositionMapping, InstructionMapping]:
+        """
+        Adjust positions in the mappings to account for the notes that are prepended to the text.
+
+        :param offset:       The length of the notes to prepend.
+        :param pos_to_node:  The position to node mapping.
+        :param pos_to_addr:  The position to address mapping.
+        :param addr_to_pos:  The address to position mapping.
+        :return:             Adjusted mappings.
+        """
+        new_pos_to_node = PositionMapping()
+        new_pos_to_addr = PositionMapping()
+        new_addr_to_pos = InstructionMapping()
+
+        for pos, node in pos_to_node.items():
+            new_pos_to_node.add_mapping(pos + offset, node.length, node.obj)
+
+        for pos, node in pos_to_addr.items():
+            new_pos_to_addr.add_mapping(pos + offset, node.length, node.obj)
+
+        for addr, pos in addr_to_pos.items():
+            new_addr_to_pos.add_mapping(addr, pos.posmap_pos + offset)
+
+        return new_pos_to_node, new_pos_to_addr, new_addr_to_pos
 
     def reapply_options(self, options):
         pass

{angr-9.2.167 → angr-9.2.169}/angr/analyses/decompiler/structured_codegen/c.py

@@ -43,6 +43,7 @@ from angr.utils.library import get_cpp_function_name
 from angr.utils.loader import is_in_readonly_segment, is_in_readonly_section
 from angr.utils.types import unpack_typeref, unpack_pointer_and_array, dereference_simtype_by_lib
 from angr.analyses.decompiler.utils import structured_node_is_simple_return
+from angr.analyses.decompiler.notes.deobfuscated_strings import DeobfuscatedStringsNote
 from angr.errors import UnsupportedNodeTypeError, AngrRuntimeError
 from angr.knowledge_plugins.cfg.memory_data import MemoryData, MemoryDataSort
 from angr.analyses import Analysis, register_analysis
@@ -254,7 +255,7 @@ class CConstruct:
         self.tags = tags or {}
         self.codegen: StructuredCodeGenerator = codegen
 
-    def c_repr(self, indent=0, pos_to_node=None, pos_to_addr=None, addr_to_pos=None):
+    def c_repr(self, initial_pos=0, indent=0, pos_to_node=None, pos_to_addr=None, addr_to_pos=None):
         """
         Creates the C representation of the code and displays it by
         constructing a large string. This function is called by each program function that needs to be decompiled.
@@ -268,7 +269,7 @@ class CConstruct:
 
         def mapper(chunks):
             # start all positions at beginning of document
-            pos = 0
+            pos = initial_pos
 
             last_insn_addr = None
 
@@ -2520,8 +2521,10 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         display_block_addrs=False,
         display_vvar_ids=False,
         min_data_addr: int = 0x400_000,
+        notes=None,
+        display_notes: bool = True,
     ):
-        super().__init__(flavor=flavor)
+        super().__init__(flavor=flavor, notes=notes)
 
         self._handlers = {
             CodeNode: self._handle_Code,
@@ -2604,6 +2607,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         self.map_addr_to_label: dict[tuple[int, int | None], CLabel] = {}
         self.cfunc: CFunction | None = None
         self.cexterns: set[CVariable] | None = None
+        self.display_notes = display_notes
 
         self._analyze()
 
@@ -2700,9 +2704,20 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         ast_to_pos = defaultdict(set)
 
         text = cfunc.c_repr(
-            indent=self._indent, pos_to_node=pos_to_node, pos_to_addr=pos_to_addr, addr_to_pos=addr_to_pos
+            initial_pos=0,
+            indent=self._indent,
+            pos_to_node=pos_to_node,
+            pos_to_addr=pos_to_addr,
+            addr_to_pos=addr_to_pos,
         )
 
+        if self.display_notes:
+            notes = self.render_notes()
+            pos_to_node, pos_to_addr, addr_to_pos = self.adjust_mapping_positions(
+                len(notes), pos_to_node, pos_to_addr, addr_to_pos
+            )
+            text = notes + text
+
         for elem, node in pos_to_node.items():
             if isinstance(node.obj, CConstant):
                 ast_to_pos[node.obj.value].add(elem)
@@ -2726,6 +2741,21 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
 
         return text, pos_to_node, pos_to_addr, addr_to_pos, ast_to_pos
 
+    def render_notes(self) -> str:
+        """
+        Render decompilation notes.
+
+        :return: A string containing all notes.
+        """
+        if not self.notes:
+            return ""
+
+        lines = []
+        for note in self.notes.values():
+            note_lines = str(note).split("\n")
+            lines += [f"// {line}" for line in note_lines]
+        return "\n".join(lines) + "\n\n"
+
     def _get_variable_type(self, var, is_global=False):
         if is_global:
             return self._variable_kb.variables["global"].get_variable_type(var)
@@ -3601,14 +3631,18 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             reference_values = {}
             type_ = unpack_typeref(type_)
             if expr.value in self.kb.obfuscations.type1_deobfuscated_strings:
-                reference_values[SimTypePointer(SimTypeChar())] = self.kb.obfuscations.type1_deobfuscated_strings[
-                    expr.value
-                ]
+                deobf_str = self.kb.obfuscations.type1_deobfuscated_strings[expr.value]
+                reference_values[SimTypePointer(SimTypeChar())] = deobf_str
+                if "deobfuscated_strings" not in self.notes:
+                    self.notes["deobfuscated_strings"] = DeobfuscatedStringsNote()
+                self.notes["deobfuscated_strings"].add_string("1", deobf_str, ref_addr=expr.value)
                 inline_string = True
             elif expr.value in self.kb.obfuscations.type2_deobfuscated_strings:
-                reference_values[SimTypePointer(SimTypeChar())] = self.kb.obfuscations.type2_deobfuscated_strings[
-                    expr.value
-                ]
+                deobf_str = self.kb.obfuscations.type2_deobfuscated_strings[expr.value]
+                reference_values[SimTypePointer(SimTypeChar())] = deobf_str
+                if "deobfuscated_strings" not in self.notes:
+                    self.notes["deobfuscated_strings"] = DeobfuscatedStringsNote()
+                self.notes["deobfuscated_strings"].add_string("2", deobf_str, ref_addr=expr.value)
                 inline_string = True
             elif isinstance(type_, SimTypePointer) and isinstance(type_.pts_to, (SimTypeChar, SimTypeBottom)):
                 # char* or void*

{angr-9.2.167 → angr-9.2.169}/angr/analyses/deobfuscator/string_obf_finder.py

@@ -173,10 +173,8 @@ class StringObfuscationFinder(Analysis):
                 continue
 
             # decompile this function and see if it "looks like" a deobfuscation function
-            try:
-                dec = self.project.analyses.Decompiler(func, cfg=cfg)
-            except Exception:  # pylint:disable=broad-exception-caught
-                continue
+            with self._resilience():
+                dec = self.project.analyses.Decompiler(func, cfg=cfg, fail_fast=self._fail_fast)  # type:ignore
             if (
                 dec.codegen is None
                 or not dec.codegen.text
@@ -470,10 +468,13 @@ class StringObfuscationFinder(Analysis):
                 continue
 
             # decompile this function and see if it "looks like" a deobfuscation function
-            try:
-                dec = self.project.analyses.Decompiler(func, cfg=cfg, expr_collapse_depth=64)
-            except Exception:  # pylint:disable=broad-exception-caught
-                continue
+            with self._resilience():
+                dec = self.project.analyses.Decompiler(
+                    func,
+                    cfg=cfg,
+                    expr_collapse_depth=64,
+                    fail_fast=self._fail_fast,  # type:ignore
+                )
             if (
                 dec.codegen is None
                 or not dec.codegen.text
@@ -666,11 +667,9 @@ class StringObfuscationFinder(Analysis):
                 continue
 
             # take a look at the content
-            try:
-                dec = self.project.analyses.Decompiler(func, cfg=cfg)
-            except Exception:  # pylint:disable=broad-exception-caught
+            with self._resilience():
                 # catch all exceptions
-                continue
+                dec = self.project.analyses.Decompiler(func, cfg=cfg, fail_fast=self._fail_fast)  # type:ignore
             if dec.codegen is None or not dec.codegen.text:
                 continue
 
@@ -736,7 +735,7 @@ class StringObfuscationFinder(Analysis):
         callinsn2content = {}
         for idx, call_site in enumerate(call_sites):
             _l.debug("Analyzing type 3 candidate call site %#x (%d/%d)...", call_site.addr, idx + 1, len(call_sites))
-            assert call_site.function_address is not None
+            assert call_site.function_address is not None and isinstance(call_site.function_address, int)
             data, _ = self._type3_prepare_and_execute(func_addr, call_site.addr, call_site.function_address, cfg)
             if data:
                 callinsn2content[call_site.instruction_addrs[-1]] = data
@@ -831,7 +830,7 @@ class StringObfuscationFinder(Analysis):
                     # at least a byte
                     continue
                 con = prop_state.load_register(reg_offset, reg_width // 8)
-                if isinstance(con, claripy.ast.Base) and con.op == "BVV":
+                if isinstance(con, claripy.ast.Base) and con.op == "BVV" and isinstance(con.concrete_value, int):
                     state.registers.store(reg_offset, claripy.BVV(con.concrete_value, reg_width))
                     if reg_offset == state.arch.bp_offset:
                         bp_set = True
@@ -851,7 +850,11 @@ class StringObfuscationFinder(Analysis):
 
         in_state = simgr.active[0]
 
-        cc = default_cc(self.project.arch.name, self.project.simos.name)(self.project.arch)
+        cc_cls = default_cc(self.project.arch.name, self.project.simos.name)
+        assert (
+            cc_cls is not None
+        ), f"Failed to obtain the default calling convention for {self.project.arch.name}-{self.project.simos.name}."
+        cc = cc_cls(self.project.arch)
         cc.STACKARG_SP_BUFF = 0  # disable shadow stack space because the binary code already sets it if needed
         cc.STACK_ALIGNMENT = 1  # disable stack address aligning because the binary code already sets it if needed
         prototype_0 = SimTypeFunction([], SimTypePointer(pts_to=SimTypeBottom(label="void"))).with_arch(
@@ -875,7 +878,7 @@ class StringObfuscationFinder(Analysis):
         out_state = callable_0.result_state
 
         # figure out what was written
-        assert out_state is not None
+        assert out_state is not None and ret_value is not None
         ptr = out_state.memory.load(ret_value, size=self.project.arch.bytes, endness=self.project.arch.memory_endness)
         if out_state.memory.load(ptr, size=4).concrete_value == 0:
             # fall back to using the return value as the pointer

{angr-9.2.167 → angr-9.2.169}/angr/analyses/deobfuscator/string_obf_opt_passes.py

@@ -7,6 +7,7 @@ from angr.ailment import Block
 from angr.ailment.statement import Statement, Call, Assignment
 from angr.ailment.expression import Const, Register, VirtualVariable
 
+from angr.analyses.decompiler.notes.deobfuscated_strings import DeobfuscatedStringsNote
 from angr.analyses.decompiler.optimization_passes.optimization_pass import OptimizationPass, OptimizationPassStage
 from angr.analyses.decompiler.optimization_passes import register_optimization_pass
 
@@ -57,9 +58,11 @@ class StringObfType3Rewriter(OptimizationPass):
                 self.is_call_or_call_assignment(last_stmt)
                 and last_stmt.ins_addr in self.kb.obfuscations.type3_deobfuscated_strings
             ):
-                new_block = self._process_block(
-                    block, self.kb.obfuscations.type3_deobfuscated_strings[block.statements[-1].ins_addr]
-                )
+                the_str = self.kb.obfuscations.type3_deobfuscated_strings[block.statements[-1].ins_addr]
+                if "deobfuscated_strings" not in self.kb.notes:
+                    self.kb.notes["deobfuscated_strings"] = DeobfuscatedStringsNote("deobfuscated_strings")
+                self.kb.notes["deobfuscated_strings"].add_string("3", the_str, ref_addr=last_stmt.ins_addr)
+                new_block = self._process_block(block, the_str)
                 if new_block is not None:
                     self._update_block(block, new_block)
 

{angr-9.2.167 → angr-9.2.169}/angr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.167
+Version: 9.2.169
 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/
@@ -16,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.167
+Requires-Dist: archinfo==9.2.169
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.167
-Requires-Dist: cle==9.2.167
+Requires-Dist: claripy==9.2.169
+Requires-Dist: cle==9.2.169
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
 Requires-Dist: protobuf>=5.28.2
@@ -30,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.167
+Requires-Dist: pyvex==9.2.169
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.167 → angr-9.2.169}/angr.egg-info/SOURCES.txt

@@ -171,6 +171,9 @@ angr/analyses/decompiler/dephication/graph_rewriting.py
 angr/analyses/decompiler/dephication/graph_vvar_mapping.py
 angr/analyses/decompiler/dephication/rewriting_engine.py
 angr/analyses/decompiler/dephication/seqnode_dephication.py
+angr/analyses/decompiler/notes/__init__.py
+angr/analyses/decompiler/notes/decompilation_note.py
+angr/analyses/decompiler/notes/deobfuscated_strings.py
 angr/analyses/decompiler/optimization_passes/__init__.py
 angr/analyses/decompiler/optimization_passes/base_ptr_save_simplifier.py
 angr/analyses/decompiler/optimization_passes/call_stmt_rewriter.py