angr 9.2.103__py3-none-macosx_11_0_arm64.whl

angr/analyses/decompiler/region_simplifiers/switch_expr_simplifier.py

@@ -0,0 +1,83 @@
+# pylint:disable=no-self-use,arguments-renamed
+from collections import OrderedDict
+
+import ailment
+
+from ..structuring.structurer_nodes import SwitchCaseNode
+from ..sequence_walker import SequenceWalker
+
+
+class SwitchExpressionSimplifier(SequenceWalker):
+    """
+    Identifies switch expressions that adds or minuses a constant, removes the constant from the switch expression, and
+    adjust all case expressions accordingly.
+    """
+
+    def __init__(self, node):
+        handlers = {
+            SwitchCaseNode: self._handle_SwitchCase,
+        }
+        super().__init__(handlers)
+
+        self.walk(node)
+
+    def _handle_SwitchCase(self, node: SwitchCaseNode, **kwargs):
+        changed = False
+
+        switch_expr = node.switch_expr
+        convert = None
+
+        # pylint: disable=import-outside-toplevel
+        from ..peephole_optimizations.remove_noop_conversions import RemoveNoopConversions
+
+        while isinstance(switch_expr, ailment.Expr.Convert):
+            optimized = RemoveNoopConversions(None, None).optimize(switch_expr)
+            if optimized is not None:
+                switch_expr = optimized
+                continue
+
+            convert = switch_expr
+            switch_expr = switch_expr.operand
+
+        if isinstance(switch_expr, ailment.Expr.BinaryOp):
+            if switch_expr.op in {"Add", "Sub"} and isinstance(switch_expr.operands[1], ailment.Expr.Const):
+                v = switch_expr.operands[1].value
+                if switch_expr.op == "Add":
+                    v = -v
+
+                new_switch_expr = switch_expr.operands[0]
+                if convert is not None:
+                    # unpack if necessary
+                    if isinstance(new_switch_expr, ailment.Expr.Convert):
+                        if new_switch_expr.to_bits == convert.from_bits:
+                            new_switch_expr = new_switch_expr.operand
+                        else:
+                            new_switch_expr = ailment.Expr.Convert(
+                                None,
+                                new_switch_expr.from_bits,
+                                convert.to_bits,
+                                convert.is_signed,
+                                new_switch_expr.operand,
+                                **convert.tags,
+                            )
+                    else:
+                        new_switch_expr = ailment.Expr.Convert(
+                            None, convert.from_bits, convert.to_bits, convert.is_signed, new_switch_expr, **convert.tags
+                        )
+
+                new_cases = OrderedDict()
+                for case_idx, case_node in node.cases.items():
+                    if isinstance(case_idx, int):
+                        new_cases[case_idx + v] = case_node
+                    elif isinstance(case_idx, tuple):
+                        new_cases[tuple(idx_ + v for idx_ in case_idx)] = case_node
+                    else:
+                        raise TypeError(f"Unsupported case_idx type {type(case_idx)}")
+                new_node = SwitchCaseNode(new_switch_expr, new_cases, default_node=node.default_node, addr=node.addr)
+                node = new_node
+                changed = True
+
+        r = super()._handle_SwitchCase(node, **kwargs)
+        if changed and r is None:
+            return node
+        return r

angr/analyses/decompiler/region_walker.py

@@ -0,0 +1,23 @@
+from .graph_region import GraphRegion
+
+
+class RegionWalker:
+    """
+    A simple traverser class that walks GraphRegion instances.
+    """
+
+    def __init__(self):
+        self._parent_region = None
+        self._current_region = None
+
+    def walk(self, region: GraphRegion):
+        for node in region.graph.nodes():
+            if isinstance(node, GraphRegion):
+                self._parent_region = node
+                self.walk(node)
+                self._parent_region = None
+            else:
+                self.walk_node(region, node)
+
+    def walk_node(self, region, node):  # pylint:disable=no-self-use,unused-argument
+        raise NotImplementedError("Please override this method with your own logic")

angr/analyses/decompiler/return_maker.py

@@ -0,0 +1,70 @@
+import logging
+
+import ailment
+
+from angr.sim_type import SimTypeBottom
+from angr.calling_conventions import SimRegArg
+from .ailgraph_walker import AILGraphWalker
+
+l = logging.getLogger(__name__)
+
+
+class ReturnMaker(AILGraphWalker):
+    """
+    Traverse the AILBlock graph of a function and update .ret_exprs of all return statements.
+    """
+
+    def __init__(self, ail_manager, arch, function, ail_graph):
+        super().__init__(ail_graph, self._handler, replace_nodes=True)
+        self.ail_manager = ail_manager
+        self.arch = arch
+        self.function = function
+        self._new_block = None
+
+        self.walk()
+
+    def _next_atom(self) -> int:
+        return self.ail_manager.next_atom()
+
+    def _handle_Return(
+        self, stmt_idx: int, stmt: ailment.Stmt.Return, block: ailment.Block | None
+    ):  # pylint:disable=unused-argument
+        if (
+            block is not None
+            and not stmt.ret_exprs
+            and self.function.prototype is not None
+            and self.function.prototype.returnty is not None
+            and type(self.function.prototype.returnty) is not SimTypeBottom
+        ):
+            new_stmt = stmt.copy()
+            ret_val = self.function.calling_convention.return_val(self.function.prototype.returnty)
+            if isinstance(ret_val, SimRegArg):
+                reg = self.arch.registers[ret_val.reg_name]
+                new_stmt.ret_exprs.append(
+                    ailment.Expr.Register(
+                        self._next_atom(),
+                        None,
+                        reg[0],
+                        ret_val.size * self.arch.byte_width,
+                        reg_name=self.arch.translate_register_name(reg[0], ret_val.size),
+                    )
+                )
+            else:
+                l.warning("Unsupported type of return expression %s.", type(ret_val))
+            new_statements = block.statements[::]
+            new_statements[stmt_idx] = new_stmt
+            self._new_block = block.copy(statements=new_statements)
+
+    def _handler(self, block):
+        walker = ailment.AILBlockWalker()
+        # we don't need to handle any statement besides Returns
+        walker.stmt_handlers.clear()
+        walker.expr_handlers.clear()
+        walker.stmt_handlers[ailment.Stmt.Return] = self._handle_Return
+
+        self._new_block = None
+        walker.walk(block)
+
+        if self._new_block is not None:
+            return self._new_block
+        return None

angr/analyses/decompiler/seq_to_blocks.py

@@ -0,0 +1,19 @@
+from ailment import Block
+
+from .sequence_walker import SequenceWalker
+
+
+class SequenceToBlocks(SequenceWalker):
+    """
+    A helper class to convert a sequence node into a list of blocks.
+    """
+
+    def __init__(self):
+        handlers = {
+            Block: self._handle_Block,
+        }
+        self.blocks = []
+        super().__init__(handlers, force_forward_scan=True, update_seqnode_in_place=False)
+
+    def _handle_Block(self, node: Block, **kwargs):  # pylint:disable=unused-argument
+        self.blocks.append(node)

angr/analyses/decompiler/sequence_walker.py

@@ -0,0 +1,235 @@
+# pylint:disable=unused-argument,useless-return
+from collections import OrderedDict
+
+import ailment
+
+from ...errors import UnsupportedNodeTypeError
+from .structuring.structurer_nodes import (
+    MultiNode,
+    CodeNode,
+    SequenceNode,
+    ConditionNode,
+    SwitchCaseNode,
+    LoopNode,
+    CascadingConditionNode,
+    ConditionalBreakNode,
+    IncompleteSwitchCaseNode,
+)
+
+
+class SequenceWalker:
+    """
+    Walks a SequenceNode and all its nodes, recursively.
+    """
+
+    def __init__(
+        self,
+        handlers=None,
+        exception_on_unsupported=False,
+        update_seqnode_in_place=True,
+        force_forward_scan: bool = False,
+    ):
+        self._update_seqnode_in_place = update_seqnode_in_place
+        self._exception_on_unsupported = exception_on_unsupported
+        self._force_forward_scan = force_forward_scan
+
+        if self._force_forward_scan and self._update_seqnode_in_place:
+            raise TypeError("force_forward_scan and update_seqnode_in_place cannot be enabled at the same time")
+
+        default_handlers = {
+            # Structurer nodes
+            CodeNode: self._handle_Code,
+            SequenceNode: self._handle_Sequence,
+            ConditionNode: self._handle_Condition,
+            CascadingConditionNode: self._handle_CascadingCondition,
+            SwitchCaseNode: self._handle_SwitchCase,
+            IncompleteSwitchCaseNode: self._handle_IncompleteSwitchCase,
+            LoopNode: self._handle_Loop,
+            MultiNode: self._handle_MultiNode,
+            ConditionalBreakNode: self._handle_ConditionalBreak,
+            ailment.Block: self._handle_Noop,
+        }
+
+        self._handlers = default_handlers
+        if handlers:
+            self._handlers.update(handlers)
+
+    def walk(self, sequence):
+        return self._handle(sequence)
+
+    #
+    # Handlers
+    #
+
+    def _handle(self, node, **kwargs):
+        handler = self._handlers.get(node.__class__, None)
+        if handler is not None:
+            return handler(node, **kwargs)
+        if self._exception_on_unsupported:
+            raise UnsupportedNodeTypeError("Node type %s is not supported yet." % type(node))
+        return None
+
+    def _handle_Code(self, node: CodeNode, **kwargs):
+        new_inner_node = self._handle(node.node, parent=node, index=0)
+        if new_inner_node is None:
+            return None
+        return CodeNode(new_inner_node, node.reaching_condition)
+
+    def _handle_Sequence(self, node, **kwargs):
+        nodes_copy = list(node.nodes)
+        changed = False
+
+        if self._force_forward_scan:
+            for i, node_ in enumerate(nodes_copy):
+                new_node = self._handle(node_, parent=node, index=i)
+                if new_node is not None:
+                    changed = True
+                    nodes_copy[i] = new_node
+        else:
+            # we iterate backwards because users of this function may invoke insert_node() directly to insert nodes
+            # to the parent node, either before the current node or after the current node. iterating backwards allows
+            # us to ensure `i` always points to the right index in node.nodes, even after custom insertions.
+            i = len(nodes_copy) - 1
+            while i > -1:
+                node_ = nodes_copy[i]
+                new_node = self._handle(node_, parent=node, index=i)
+                if new_node is not None:
+                    changed = True
+                    if self._update_seqnode_in_place:
+                        node.nodes[i] = new_node
+                    else:
+                        nodes_copy[i] = new_node
+                i -= 1
+
+        if not changed:
+            return None
+        if self._update_seqnode_in_place:
+            return node
+        return SequenceNode(node.addr, nodes=nodes_copy)
+
+    def _handle_MultiNode(self, node, **kwargs):
+        changed = False
+        nodes_copy = list(node.nodes)
+
+        if self._force_forward_scan:
+            for i, node_ in enumerate(nodes_copy):
+                new_node = self._handle(node_, parent=node, index=i)
+                if new_node is not None:
+                    changed = True
+                    node.nodes[i] = new_node
+        else:
+            i = len(nodes_copy) - 1
+            while i > -1:
+                node_ = nodes_copy[i]
+                new_node = self._handle(node_, parent=node, index=i)
+                if new_node is not None:
+                    changed = True
+                    node.nodes[i] = new_node
+                i -= 1
+        return None if not changed else node
+
+    def _handle_SwitchCase(self, node, **kwargs):
+        self._handle(node.switch_expr, parent=node, label="switch_expr")
+
+        changed = False
+        new_cases = OrderedDict()
+        for idx in list(node.cases.keys()):
+            case = node.cases[idx]
+            new_case = self._handle(case, parent=node, index=idx, label="case")
+            if new_case is not None:
+                changed = True
+                new_cases[idx] = new_case
+            else:
+                new_cases[idx] = case
+
+        new_default_node = None
+        if node.default_node is not None:
+            new_default_node = self._handle(node.default_node, parent=node, index=0, label="default")
+            if new_default_node is not None:
+                changed = True
+            else:
+                new_default_node = node.default_node
+
+        if changed:
+            return SwitchCaseNode(node.switch_expr, new_cases, new_default_node, addr=node.addr)
+
+        return None
+
+    def _handle_IncompleteSwitchCase(self, node: IncompleteSwitchCaseNode, **kwargs):
+        changed = False
+        new_cases = []
+        for idx, case in enumerate(node.cases):
+            new_case = self._handle(case, parent=node, index=idx, label="case")
+            if new_case is not None:
+                changed = True
+                new_cases.append(new_case)
+            else:
+                new_cases.append(case)
+
+        new_head = None
+        if node.head is not None:
+            new_head = self._handle(node.head, parent=node, index=0, label="default")
+            if new_head is not None:
+                changed = True
+            else:
+                new_head = node.head
+
+        if changed:
+            return IncompleteSwitchCaseNode(node.addr, new_head, new_cases)
+
+        return None
+
+    def _handle_Loop(self, node: LoopNode, **kwargs):
+        if node.initializer is not None:
+            self._handle(node.initializer)
+        if node.iterator is not None:
+            self._handle(node.iterator)
+        if node.condition is not None:
+            self._handle(node.condition, parent=node, label="condition")
+        seq_node = self._handle(node.sequence_node, parent=node, label="body", index=0)
+        if seq_node is not None:
+            return LoopNode(
+                node.sort,
+                node.condition,
+                seq_node,
+                addr=node.addr,
+                continue_addr=node.continue_addr,
+                initializer=node.initializer,
+                iterator=node.iterator,
+            )
+        return None
+
+    def _handle_Condition(self, node, **kwargs):
+        if node.true_node is not None:
+            new_true_node = self._handle(node.true_node, parent=node, index=0)
+        else:
+            new_true_node = None
+
+        if node.false_node is not None:
+            new_false_node = self._handle(node.false_node, parent=node, index=1)
+        else:
+            new_false_node = None
+
+        if new_true_node is None and new_false_node is None:
+            return None
+
+        return ConditionNode(
+            node.addr,
+            node.reaching_condition,
+            node.condition,
+            node.true_node if new_true_node is None else new_true_node,
+            false_node=node.false_node if new_false_node is None else new_false_node,
+        )
+
+    def _handle_CascadingCondition(self, node: CascadingConditionNode, **kwargs):
+        for index, (_, child_node) in enumerate(node.condition_and_nodes):
+            self._handle(child_node, parent=node, index=index)
+        if node.else_node is not None:
+            self._handle(node.else_node, parent=node, index=-1)
+        return None
+
+    def _handle_ConditionalBreak(self, node: ConditionalBreakNode, **kwargs):  # pylint:disable=no-self-use
+        return None
+
+    def _handle_Noop(self, *args, **kwargs):  # pylint:disable=no-self-use
+        return None

angr/analyses/decompiler/structured_codegen/__init__.py

@@ -0,0 +1,10 @@
+from .base import (
+    BaseStructuredCodeGenerator,
+    InstructionMapping,
+    InstructionMappingElement,
+    PositionMappingElement,
+    PositionMapping,
+)
+from .c import CStructuredCodeGenerator, CStructuredCodeWalker
+from .dwarf_import import ImportSourceCode
+from .dummy import DummyStructuredCodeGenerator

angr/analyses/decompiler/structured_codegen/base.py

@@ -0,0 +1,132 @@
+from sortedcontainers import SortedDict
+
+from ....sim_variable import SimVariable
+
+#
+#   Position Mapping Classes
+#
+
+
+class PositionMappingElement:
+    __slots__ = ("start", "length", "obj")
+
+    def __init__(self, start, length, obj):
+        self.start: int = start
+        self.length: int = length
+        self.obj = obj
+
+    def __contains__(self, offset):
+        return self.start <= offset < self.start + self.length
+
+    def __repr__(self):
+        return "<%d-%d: %s>" % (self.start, self.start + self.length, self.obj)
+
+
+class PositionMapping:
+    __slots__ = ("_posmap",)
+
+    DUPLICATION_CHECK = True
+
+    def __init__(self):
+        self._posmap: SortedDict | dict[int, PositionMappingElement] = SortedDict()
+
+    def items(self):
+        return self._posmap.items()
+
+    #
+    # Public methods
+    #
+
+    def add_mapping(self, start_pos, length, obj):
+        # duplication check
+        if self.DUPLICATION_CHECK:
+            try:
+                pre = next(self._posmap.irange(maximum=start_pos, reverse=True))
+                if start_pos in self._posmap[pre]:
+                    raise ValueError("New mapping is overlapping with an existing element.")
+            except StopIteration:
+                pass
+
+        self._posmap[start_pos] = PositionMappingElement(start_pos, length, obj)
+
+    def get_node(self, pos: int):
+        element = self.get_element(pos)
+        if element is None:
+            return None
+        return element.obj
+
+    def get_element(self, pos: int) -> PositionMappingElement | None:
+        try:
+            pre = next(self._posmap.irange(maximum=pos, reverse=True))
+        except StopIteration:
+            return None
+
+        element = self._posmap[pre]
+        if pos in element:
+            return element
+        return None
+
+
+class InstructionMappingElement:
+    __slots__ = ("ins_addr", "posmap_pos")
+
+    def __init__(self, ins_addr, posmap_pos):
+        self.ins_addr: int = ins_addr
+        self.posmap_pos: int = posmap_pos
+
+    def __contains__(self, offset: int):
+        return self.ins_addr == offset
+
+    def __repr__(self):
+        return "<%d: %d>" % (self.ins_addr, self.posmap_pos)
+
+
+class InstructionMapping:
+    __slots__ = ("_insmap",)
+
+    def __init__(self):
+        self._insmap: SortedDict | dict[int, InstructionMappingElement] = SortedDict()
+
+    def items(self):
+        return self._insmap.items()
+
+    def add_mapping(self, ins_addr, posmap_pos):
+        if ins_addr in self._insmap:
+            if posmap_pos <= self._insmap[ins_addr].posmap_pos:
+                self._insmap[ins_addr] = InstructionMappingElement(ins_addr, posmap_pos)
+        else:
+            self._insmap[ins_addr] = InstructionMappingElement(ins_addr, posmap_pos)
+
+    def get_nearest_pos(self, ins_addr: int) -> int | None:
+        try:
+            pre_max = next(self._insmap.irange(maximum=ins_addr, reverse=True))
+            pre_min = next(self._insmap.irange(minimum=ins_addr, reverse=True))
+        except StopIteration:
+            return None
+
+        e1: InstructionMappingElement = self._insmap[pre_max]
+        e2: InstructionMappingElement = self._insmap[pre_min]
+
+        if abs(ins_addr - e1.ins_addr) <= abs(ins_addr - e2.ins_addr):
+            return e1.posmap_pos
+        else:
+            return e2.posmap_pos
+
+
+class BaseStructuredCodeGenerator:
+    def __init__(self, flavor=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
+
+    def reapply_options(self, options):
+        pass
+
+    def regenerate_text(self) -> None:
+        pass
+
+    def reload_variable_types(self) -> None:
+        pass