angr 9.2.177__cp310-abi3-win_amd64.whl → 9.2.179__cp310-abi3-win_amd64.whl

angr/analyses/disassembly.py

@@ -34,7 +34,7 @@ class DisassemblyPiece:
     addr = None
     ident = float("nan")
 
-    def render(self, formatting=None):
+    def render(self, formatting=None) -> list[str]:
         x = self._render(formatting)
         if len(x) == 1:
             return [self.highlight(x[0], formatting)]
@@ -73,7 +73,7 @@ class DisassemblyPiece:
             pass
         return string
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         return False
 
 
@@ -175,7 +175,7 @@ class Instruction(DisassemblyPiece):
         self.arch = self.project.arch
         self.format = ""
         self.components = ()
-        self.opcode = None
+        self.opcode: Opcode = None  # type:ignore
         self.operands = []
 
         # the following members will be filled in after dissecting the instruction
@@ -261,7 +261,11 @@ class Instruction(DisassemblyPiece):
                     if i > 0 and opr_pieces[i - 1] == "-":
                         v = -v
                         cur_operand.pop()
-                    cur_operand.append(Value(v, with_sign))
+                    with_pound_sign = False
+                    if i > 0 and opr_pieces[i - 1] == "#":
+                        with_pound_sign = True
+                        cur_operand.pop()
+                    cur_operand.append(Value(v, with_sign, render_with_pound_sign=with_pound_sign))
                 elif p[0].isalpha() and p in self.arch.registers:
                     cur_operand.append(Register(p))
                 else:
@@ -592,7 +596,7 @@ class Opcode(DisassemblyPiece):
 class Operand(DisassemblyPiece):
     def __init__(self, op_num, children, parentinsn):
         self.addr = parentinsn.addr
-        self.children = children
+        self.children: list = children
         self.parentinsn = parentinsn
         self.op_num = op_num
         self.ident = (self.addr, "operand", self.op_num)
@@ -639,14 +643,33 @@ class Operand(DisassemblyPiece):
         operand = cls(op_num, children, parentinsn)
 
         # Post-processing
-        if cls is MemoryOperand and parentinsn.arch.name in {"AMD64"} and len(operand.values) == 2:
+        if cls is MemoryOperand:
+            operand = Operand._post_process_memory_operand(parentinsn, operand)
+
+        return operand
+
+    @staticmethod
+    def _post_process_memory_operand(parentinsn: Instruction, operand: MemoryOperand) -> Operand:
+        archname = parentinsn.arch.name
+        if archname in {"AMD64", "ARM", "ARMEL", "ARMHF", "ARMCortexM"} and len(operand.values) == 2:
             op0, op1 = operand.values
             if type(op0) is Register and op0.is_ip and type(op1) is Value:
-                # Indirect addressing in x86_64
+                # Indirect addressing in x86-64 and ARM
                 # 400520  push [rip+0x200782] ==>  400520  push [0x600ca8]
-                absolute_addr = parentinsn.addr + parentinsn.size + op1.val
+                # 80410e6  ldr r1, [pc, #0x98]  ==>   80410e6  ldr r1, [0x8041182]
+                match archname:
+                    case "AMD64":
+                        absolute_addr = parentinsn.addr + parentinsn.size + op1.val
+                    case "ARM" | "ARMEL" | "ARMHF" | "ARMCortexM":
+                        if parentinsn.addr & 1:
+                            # thumb mode
+                            absolute_addr = (parentinsn.addr & 0xFFFF_FFFE) + 4 + op1.val
+                        else:
+                            # arm mode
+                            absolute_addr = parentinsn.addr + 8 + op1.val
+                    case _:
+                        raise AngrTypeError(f"Unsupported architecture {archname} for post-processing memory operand.")
                 return MemoryOperand(1, [*operand.prefix, "[", Value(absolute_addr, False), "]"], parentinsn)
-
         return operand
 
 
@@ -680,13 +703,15 @@ class MemoryOperand(Operand):
         # [ '[', Register, ']' ]
         # or
         # [ Value, '(', Register, ')' ]
+        # or
+        # [ Register, ",", Value]
 
         # it will be converted into more meaningful and Pythonic properties
 
         self.segment_selector = None
         self.prefix = []
         self.suffix_str = ""  # could be arm pre index mark "!"
-        self.values = []
+        self.values: list[str | DisassemblyPiece] = []
         self.offset = []
         # offset_location
         # - prefix: -0xff00($gp)
@@ -698,6 +723,10 @@ class MemoryOperand(Operand):
         # - curly: {rax+0x10}
         # - paren: (rax+0x10)
         self.values_style = "square"
+        # separator (between register and value)
+        # - "": rax+0x10
+        # - "comma": r0, #0x10
+        self.separator = ""
 
         try:
             if "[" in self.children:
@@ -711,8 +740,8 @@ class MemoryOperand(Operand):
             l.error("Failed to parse operand children %s. Please report to Fish.", self.children)
 
             # setup all dummy properties
-            self.prefix = None
-            self.values = None
+            self.prefix = []
+            self.values = []
 
     def _parse_memop_squarebracket(self):
         if self.children[0] != "[":
@@ -746,6 +775,27 @@ class MemoryOperand(Operand):
                 raise ValueError
 
         self.values = self.children[square_bracket_pos + 1 : close_square_pos]
+        if len(self.values) >= 3 and self.values[1] == ",":
+            # arm style memory operand: [r0, #0x10], or [pc, r3, lsl #1]
+            self.separator = "comma"
+            # remove all commas and consolidate all remaining strings
+            new_values = []
+            last_item = None
+            for v in self.values:
+                if v == ",":
+                    if last_item is not None:
+                        new_values.append(last_item)
+                        last_item = None
+                elif isinstance(v, str):
+                    last_item = v if last_item is None else last_item + v
+                else:
+                    if last_item is not None:
+                        new_values.append(last_item)
+                        last_item = None
+                    new_values.append(v)
+            if last_item is not None:
+                new_values.append(last_item)
+            self.values = new_values
 
     def _parse_memop_paren(self):
         offset = []
@@ -801,7 +851,8 @@ class MemoryOperand(Operand):
         if custom_values_str is not None:
             value_str = custom_values_str
         else:
-            value_str = "".join(x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.values)
+            sep = "," if self.separator == "comma" else ""
+            value_str = sep.join(x.render(formatting)[0] if not isinstance(x, str) else x for x in self.values)
 
         if values_style == "curly":
             left_paren, right_paren = "{", "}"
@@ -811,7 +862,7 @@ class MemoryOperand(Operand):
             left_paren, right_paren = "[", "]"
 
         if self.offset:
-            offset_str = "".join(x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.offset)
+            offset_str = "".join(x.render(formatting)[0] if not isinstance(x, str) else x for x in self.offset)
 
             # combine values and offsets according to self.offset_location
             if self.offset_location == "prefix":
@@ -829,9 +880,7 @@ class MemoryOperand(Operand):
             prefix_str += " "
 
             if self.offset:
-                offset_str = "".join(
-                    x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.offset
-                )
+                offset_str = "".join(x.render(formatting)[0] if not isinstance(x, str) else x for x in self.offset)
 
                 # combine values and offsets according to self.offset_location
                 if self.offset_location == "prefix":
@@ -873,12 +922,14 @@ class Register(OperandPiece):
 
 
 class Value(OperandPiece):
-    def __init__(self, val, render_with_sign):
+    def __init__(self, val, render_with_sign, render_with_pound_sign: bool = False):
         self.val = val
         self.render_with_sign = render_with_sign
+        self.render_with_pound_sign = render_with_pound_sign
 
     @property
     def project(self):
+        assert self.parentop is not None
         return self.parentop.parentinsn.project
 
     def __eq__(self, other):
@@ -888,26 +939,26 @@ class Value(OperandPiece):
         if formatting is not None:
             try:
                 style = formatting["int_styles"][self.ident]
-                if style[0] == "hex":
-                    if self.render_with_sign:
-                        return [f"{self.val:+#x}"]
-                    return [f"{self.val:#x}"]
-                if style[0] == "dec":
-                    if self.render_with_sign:
-                        return [f"{self.val:+d}"]
-                    return [str(self.val)]
                 if style[0] == "label":
                     labeloffset = style[1]
                     if labeloffset == 0:
                         lbl = self.project.kb.labels[self.val]
                         return [lbl]
-                    return [
-                        "{}{}{:#+x}".format(
-                            "+" if self.render_with_sign else "",
-                            self.project.kb.labels[self.val + labeloffset],
-                            labeloffset,
-                        )
-                    ]
+                    s = "{}{}{:#+x}".format(
+                        "+" if self.render_with_sign else "",
+                        self.project.kb.labels[self.val + labeloffset],
+                        labeloffset,
+                    )
+                elif style[0] == "hex":
+                    s = f"{self.val:+#x}" if self.render_with_sign else f"{self.val:#x}"
+                    if self.render_with_pound_sign:
+                        s = "#" + s
+                else:  # "dec"
+                    s = f"{self.val:+d}" if self.render_with_sign else str(self.val)
+
+                if self.render_with_pound_sign:
+                    s = "#" + s
+                return [s]
             except KeyError:
                 pass
 
@@ -927,9 +978,10 @@ class Value(OperandPiece):
             return [("+" if self.render_with_sign else "") + lbl]
         if func is not None:
             return [func.demangled_name]
-        if self.render_with_sign:
-            return [f"{self.val:+#x}"]
-        return [f"{self.val:#x}"]
+        s = f"{self.val:+#x}" if self.render_with_sign else f"{self.val:#x}"
+        if self.render_with_pound_sign:
+            s = "#" + s
+        return [s]
 
 
 class Comment(DisassemblyPiece):
@@ -1079,10 +1131,11 @@ class Disassembly(Analysis):
         if irsb.statements is not None:
             if pcode is not None and isinstance(self.project.factory.default_engine, pcode.HeavyPcodeMixin):
                 addr = None
-                for stmt_idx, op in enumerate(irsb._ops):
+                for stmt_idx, op in enumerate(irsb._ops):  # type:ignore
                     if op.opcode == pypcode.OpCode.IMARK:
                         addr = op.inputs[0].offset
                     else:
+                        assert addr is not None
                         addr_to_ops_map[addr].append(IROp(addr, stmt_idx, op, irsb))
             else:
                 for seq, stmt in enumerate(irsb.statements):
@@ -1166,22 +1219,23 @@ class Disassembly(Analysis):
         buf = []
 
         if formatting is None:
+            colors = (
+                {
+                    "address": "gray",
+                    "bytes": "cyan",
+                    "edge": "yellow",
+                    Label: "bright_yellow",
+                    ConstantOperand: "cyan",
+                    MemoryOperand: "yellow",
+                    Comment: "gray",
+                    Hook: "green",
+                }
+                if ansi_color_enabled and color
+                else {}
+            )
             formatting = {
-                "colors": (
-                    {
-                        "address": "gray",
-                        "bytes": "cyan",
-                        "edge": "yellow",
-                        Label: "bright_yellow",
-                        ConstantOperand: "cyan",
-                        MemoryOperand: "yellow",
-                        Comment: "gray",
-                        Hook: "green",
-                    }
-                    if ansi_color_enabled and color
-                    else {}
-                ),
-                "format_callback": lambda item, s: ansi_color(s, formatting["colors"].get(type(item), None)),
+                "colors": colors,
+                "format_callback": lambda item, s: ansi_color(s, colors.get(type(item), None)),
             }
 
         def col(item: Any) -> str | None:
@@ -1234,12 +1288,14 @@ class Disassembly(Analysis):
                 # Format the instruction's address, bytes, disassembly, and comment
                 s_plain = format_address(item.addr, False)
                 s = format_address(item.addr)
+                bytes_column = 0
                 if show_bytes:
                     bytes_column = len(s_plain)
                     s_plain += format_bytes(insn_bytes[0], False)
                     s += format_bytes(insn_bytes[0])
                 s_plain += item.render()[0]
                 s += item.render(formatting)[0]
+                comment_column = 0
                 if comment is not None:
                     comment_column = len(s_plain)
                     s += format_comment(comment.text[0])

angr/analyses/proximity_graph.py

@@ -357,26 +357,27 @@ class ProximityGraphAnalysis(Analysis):
         def _handle_Call(
             stmt_idx: int, stmt: ailment.Stmt.Call, block: ailment.Block | None  # pylint:disable=unused-argument
         ):  # pylint:disable=unused-argument
-            func_node = self.kb.functions[stmt.target.value]
-            ref_at = {stmt.ins_addr}
-
-            # extract arguments
-            args = []
-            if stmt.args:
-                for arg in stmt.args:
-                    self._arg_handler(arg, args, string_refs)
-
-            if (
-                self._expand_funcs and func_node.addr in self._expand_funcs
-            ):  # pylint:disable=unsupported-membership-test
-                new_node = FunctionProxiNode(func_node, ref_at=ref_at)
-                if new_node not in to_expand:
-                    to_expand.append(new_node)
-            else:
-                new_node = CallProxiNode(func_node, ref_at=ref_at, args=tuple(args) if args is not None else None)
+            if isinstance(stmt.target, ailment.Expr.Const) and self.kb.functions.contains_addr(stmt.target.value):
+                func_node = self.kb.functions[stmt.target.value]
+                ref_at = {stmt.ins_addr}
+
+                # extract arguments
+                args = []
+                if stmt.args:
+                    for arg in stmt.args:
+                        self._arg_handler(arg, args, string_refs)
+
+                if (
+                    self._expand_funcs and func_node.addr in self._expand_funcs
+                ):  # pylint:disable=unsupported-membership-test
+                    new_node = FunctionProxiNode(func_node, ref_at=ref_at)
+                    if new_node not in to_expand:
+                        to_expand.append(new_node)
+                else:
+                    new_node = CallProxiNode(func_node, ref_at=ref_at, args=tuple(args) if args is not None else None)
 
-            # stmt has been properly handled, add the proxi node to the list
-            self.handled_stmts.append(new_node)
+                # stmt has been properly handled, add the proxi node to the list
+                self.handled_stmts.append(new_node)
 
         # This should have the same functionality as the previous handler
         def _handle_CallExpr(

angr/analyses/s_propagator.py

@@ -15,6 +15,7 @@ from angr.ailment.expression import (
     Load,
     Convert,
     Expression,
+    Tmp,
 )
 from angr.ailment.statement import Assignment, Store, Return, Jump, ConditionalJump
 
@@ -164,7 +165,7 @@ class SPropagatorAnalysis(Analysis):
                 assert v is not None
                 const_vvars[vvar_id] = v
                 for vvar_at_use, useloc in vvar_uselocs[vvar_id]:
-                    replacements[useloc][vvar_at_use] = v
+                    self.replace(replacements, useloc, vvar_at_use, v)
                 continue
 
             v = phi_assignment_get_src(stmt)
@@ -185,7 +186,7 @@ class SPropagatorAnalysis(Analysis):
                         const_value = const_vvars[next(iter(all_int_src_varids))]
                         const_vvars[vvar.varid] = const_value
                         for vvar_at_use, useloc in vvar_uselocs[vvar.varid]:
-                            replacements[useloc][vvar_at_use] = const_value
+                            self.replace(replacements, useloc, vvar_at_use, const_value)
 
         # function mode only
         if self.mode == "function":
@@ -226,7 +227,7 @@ class SPropagatorAnalysis(Analysis):
                     if can_replace:
                         # we can propagate this load because there is no store between its def and use
                         for vvar_used, vvar_useloc in vvar_uselocs_set:
-                            replacements[vvar_useloc][vvar_used] = stmt.src
+                            self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                         continue
 
                 if (
@@ -241,7 +242,7 @@ class SPropagatorAnalysis(Analysis):
                     uselocs = {loc for _, loc in vvar_uselocs_set}
                     if self.is_vvar_used_for_addr_loading_switch_case(uselocs, blocks) and not has_tmp_expr(stmt.src):
                         for vvar_used, vvar_useloc in vvar_uselocs_set:
-                            replacements[vvar_useloc][vvar_used] = stmt.src
+                            self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                         # mark the vvar as dead and should be removed
                         self.model.dead_vvar_ids.add(vvar.varid)
                         continue
@@ -255,7 +256,7 @@ class SPropagatorAnalysis(Analysis):
                             and not has_tmp_expr(stmt.src)
                         ):
                             # we can propagate this load because there is no store between its def and use
-                            replacements[vvar_useloc][vvar_used] = stmt.src
+                            self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                             continue
 
                         if is_const_and_vvar_assignment(stmt) and not has_tmp_expr(stmt.src):
@@ -272,9 +273,9 @@ class SPropagatorAnalysis(Analysis):
                                     and stmt.src.oident == useloc_stmt.dst.oident
                                     and stmt.src.category == useloc_stmt.dst.category
                                 ):
-                                    replacements[vvar_useloc][vvar_used] = stmt.src
+                                    self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                             else:
-                                replacements[vvar_useloc][vvar_used] = stmt.src
+                                self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                             continue
 
                     else:
@@ -288,7 +289,7 @@ class SPropagatorAnalysis(Analysis):
                                 # this vvar is used once if we exclude its uses at ret sites or jump sites. we can
                                 # propagate it
                                 for vvar_used, vvar_useloc in vvar_uselocs_set:
-                                    replacements[vvar_useloc][vvar_used] = stmt.src
+                                    self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                                 continue
 
                             if (
@@ -304,7 +305,7 @@ class SPropagatorAnalysis(Analysis):
                                     # remove duplicate use locs (e.g., if the variable is used multiple times by the
                                     # same statement) - but ensure stmt is simple enough
                                     for vvar_used, vvar_useloc in vvar_uselocs_set:
-                                        replacements[vvar_useloc][vvar_used] = stmt.src
+                                        self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                                     continue
 
                 # special logic for global variables: if it's used once or multiple times, and the variable is never
@@ -332,7 +333,7 @@ class SPropagatorAnalysis(Analysis):
                             )
                         if not gv_updated:
                             for vvar_used, vvar_useloc in vvar_uselocs_set:
-                                replacements[vvar_useloc][vvar_used] = stmt.src
+                                self.replace(replacements, vvar_useloc, vvar_used, stmt.src)
                             continue
 
         for vvar_id, uselocs in vvar_uselocs.items():
@@ -353,7 +354,7 @@ class SPropagatorAnalysis(Analysis):
                             if sp_bits is not None and vvar.bits < sp_bits:
                                 # truncation needed
                                 v = Convert(None, sp_bits, vvar.bits, False, v)
-                            replacements[useloc][vvar_at_use] = v
+                            self.replace(replacements, useloc, vvar_at_use, v)
                     continue
                 if not self._bp_as_gpr and vvar.oident == self.project.arch.bp_offset:
                     bp_bits = (
@@ -368,7 +369,7 @@ class SPropagatorAnalysis(Analysis):
                             if bp_bits is not None and vvar.bits < bp_bits:
                                 # truncation needed
                                 v = Convert(None, bp_bits, vvar.bits, False, v)
-                            replacements[useloc][vvar_at_use] = v
+                            self.replace(replacements, useloc, vvar_at_use, v)
                     continue
 
         # find all tmp definitions
@@ -390,9 +391,8 @@ class SPropagatorAnalysis(Analysis):
                     if r:
                         # we can propagate it!
                         for tmp_used, tmp_use_stmtidx in tmp_uses:
-                            replacements[
-                                CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
-                            ][tmp_used] = stmt.src
+                            loc = CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
+                            self.replace(replacements, loc, tmp_used, stmt.src)
                         continue
 
                     r = is_const_vvar_tmp_assignment(stmt)
@@ -404,9 +404,8 @@ class SPropagatorAnalysis(Analysis):
                             v = stmt.src
 
                         for tmp_used, tmp_use_stmtidx in tmp_uses:
-                            replacements[
-                                CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
-                            ][tmp_used] = v
+                            loc = CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
+                            self.replace(replacements, loc, tmp_used, v)
                         continue
 
                     if len(tmp_uses) <= 2 and is_const_vvar_load_dirty_assignment(stmt):
@@ -422,9 +421,8 @@ class SPropagatorAnalysis(Analysis):
                                 # we can propagate this load because either we do not consider memory aliasing problem
                                 # within the same instruction (blocks must be originally lifted with
                                 # CROSS_INSN_OPT=False), or there is no store between its def and use.
-                                replacements[
-                                    CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
-                                ][tmp_used] = stmt.src
+                                loc = CodeLocation(block_loc.block_addr, tmp_use_stmtidx, block_idx=block_loc.block_idx)
+                                self.replace(replacements, loc, tmp_used, stmt.src)
 
         self.model.replacements = replacements
 
@@ -538,5 +536,9 @@ class SPropagatorAnalysis(Analysis):
 
         return g
 
+    @staticmethod
+    def replace(replacements: dict, loc, expr: VirtualVariable | Tmp, value: Expression) -> None:
+        replacements[loc][expr] = value
+
 
 register_analysis(SPropagatorAnalysis, "SPropagator")

angr/analyses/smc.py

@@ -112,9 +112,8 @@ class SelfModifyingCodeAnalysis(Analysis):
         if subject is None:
             subject = self.project.entry
         if isinstance(subject, str):
-            try:
-                addr = self.project.kb.labels.lookup(subject)
-            except KeyError:
+            addr = self.project.kb.labels.lookup(subject)
+            if addr is None:
                 addr = self.project.kb.functions[subject].addr
         elif isinstance(subject, Function):
             addr = subject.addr

angr/flirt/__init__.py

@@ -26,6 +26,60 @@ LIBRARY_TO_SIGNATURES: dict[str, list[FlirtSignature]] = defaultdict(list)
 STRING_TO_LIBRARIES: dict[str, set[str]] = defaultdict(set)
 
 
+def load_signature(sig_path: str, meta_path: str | None = None) -> tuple[str, FlirtSignature] | None:
+    """
+    Load a single FLIRT signature from a specific path.
+
+    :param sig_path:    Location of the FLIRT signature.
+    :return:            A FlirtSignature object if loading was successful, None otherwise.
+    """
+
+    # parse it
+    try:
+        with open(sig_path, "rb") as f:
+            sig_parsed = FlirtSignatureParsed.parse(f)
+    except FlirtSignatureError:
+        return None
+
+    # is there a meta data file?
+    if meta_path is not None and os.path.isfile(meta_path):
+        # yes!
+        with open(meta_path) as f:
+            meta = json.load(f)
+
+        arch = str(meta.get("arch", "Unknown"))
+        platform = str(meta.get("platform", "UnknownOS"))
+        os_name = meta.get("os", None)
+        os_version = meta.get("os_version", None)
+        compiler = meta.get("compiler", None)
+        compiler_version = meta.get("compiler_version", None)
+        unique_strings = meta.get("unique_strings", None)
+
+    else:
+        # nope... we need to extract information from the signature file
+        arch = flirt_arch_to_arch_name(sig_parsed.arch, sig_parsed.app_types)
+        platform = flirt_os_type_to_os_name(sig_parsed.os_types)
+        os_name = None
+        os_version = None
+        unique_strings = None
+        compiler = None
+        compiler_version = None
+
+    signature = FlirtSignature(
+        arch,
+        platform,
+        sig_parsed.libname,
+        sig_path,
+        unique_strings=unique_strings,
+        compiler=compiler,
+        compiler_version=compiler_version,
+        os_name=os_name,
+        os_version=os_version,
+    )
+
+    return arch, signature
+
+
 def load_signatures(path: str) -> None:
     """
     Recursively load all FLIRT signatures under a specific path.
@@ -40,52 +94,14 @@ def load_signatures(path: str) -> None:
     for root, _, filenames in os.walk(path):
         for filename in filenames:
             if filename.endswith(".sig"):
-                # parse it
                 sig_path = os.path.join(root, filename)
-                try:
-                    with open(sig_path, "rb") as f:
-                        sig_parsed = FlirtSignatureParsed.parse(f)
-                except FlirtSignatureError:
+                meta_path = os.path.join(root, filename[:-4] + ".meta")
+                r = load_signature(sig_path, meta_path=meta_path)
+                if r is None:
                     _l.warning("Failed to load FLIRT signature file %s.", sig_path)
                     continue
 
-                # is there a meta data file?
-                meta_path = os.path.join(root, filename[:-4] + ".meta")
-                if os.path.isfile(meta_path):
-                    # yes!
-                    with open(meta_path) as f:
-                        meta = json.load(f)
-
-                    arch = str(meta.get("arch", "Unknown"))
-                    platform = str(meta.get("platform", "UnknownOS"))
-                    os_name = meta.get("os", None)
-                    os_version = meta.get("os_version", None)
-                    compiler = meta.get("compiler", None)
-                    compiler_version = meta.get("compiler_version", None)
-                    unique_strings = meta.get("unique_strings", None)
-
-                else:
-                    # nope... we need to extract information from the signature file
-                    arch = flirt_arch_to_arch_name(sig_parsed.arch, sig_parsed.app_types)
-                    platform = flirt_os_type_to_os_name(sig_parsed.os_types)
-                    os_name = None
-                    os_version = None
-                    unique_strings = None
-                    compiler = None
-                    compiler_version = None
-
-                signature = FlirtSignature(
-                    arch,
-                    platform,
-                    sig_parsed.libname,
-                    sig_path,
-                    unique_strings=unique_strings,
-                    compiler=compiler,
-                    compiler_version=compiler_version,
-                    os_name=os_name,
-                    os_version=os_version,
-                )
-
+                arch, signature = r
                 FLIRT_SIGNATURES_BY_ARCH[arch].append(signature)
 
     # fill in LIBRARY_TO_SIGNATURES and STRING_TO_LIBRARIES
@@ -95,3 +111,14 @@ def load_signatures(path: str) -> None:
             if sig.unique_strings:
                 for us in sig.unique_strings:
                     STRING_TO_LIBRARIES[us].add(sig.sig_name)
+
+
+__all__ = (
+    "FLIRT_SIGNATURES_BY_ARCH",
+    "FS",
+    "LIBRARY_TO_SIGNATURES",
+    "STRING_TO_LIBRARIES",
+    "FlirtSignature",
+    "load_signature",
+    "load_signatures",
+)