angr 9.2.161__cp310-abi3-manylinux2014_x86_64.whl → 9.2.163__cp310-abi3-manylinux2014_x86_64.whl

angr/analyses/flirt/flirt_sig.py

@@ -146,7 +146,7 @@ class FlirtSignatureParsed:
         name_lst = []
         name_end = False  # in case the function name is too long...
         for _ in range(1024):  # max length of a function name
-            if next_byte < 0x20:
+            if next_byte < 0x20 or next_byte >= 0x80:
                 name_end = True
                 break
             name_lst.append(next_byte)
@@ -347,7 +347,10 @@ class FlirtSignatureParsed:
         # is it compressed?
         if obj.features & FlirtFeatureFlag.FEATURE_COMPRESSED:
             data = file_obj.read()
-            decompressed = BytesIO(zlib.decompress(data))
+            try:
+                decompressed = BytesIO(zlib.decompress(data))
+            except zlib.error as ex:
+                raise FlirtSignatureError(f"Failed to decompress FLIRT signature: {ex}") from ex
             file_obj = decompressed
 
         root = obj.parse_tree(file_obj, root=True)

angr/analyses/reaching_definitions/function_handler.py

@@ -575,7 +575,7 @@ class FunctionHandler:
         sub_rda = state.analysis.project.analyses.ReachingDefinitions(
             data.function,
             observe_all=state.analysis._observe_all,
-            observation_points=list(state.analysis._observation_points or []).extend(return_observation_points),
+            observation_points=list(state.analysis._observation_points or []) + return_observation_points,
             observe_callback=state.analysis._observe_callback,
             dep_graph=state.dep_graph,
             function_handler=self,
@@ -584,6 +584,7 @@ class FunctionHandler:
         # migrate data from sub_rda to its parent
         state.analysis.function_calls.update(sub_rda.function_calls)
         state.analysis.model.observed_results.update(sub_rda.model.observed_results)
+        state.all_definitions |= sub_rda.all_definitions
 
         sub_ld = get_exit_livedefinitions(data.function, sub_rda.model)
         if sub_ld is not None:

angr/analyses/reaching_definitions/function_handler_library/stdio.py

@@ -156,14 +156,14 @@ class LibcStdioHandlers(FunctionHandler):
     @FunctionCallDataUnwrapped.decorate
     def handle_impl_fread(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         size = state.get_concrete_value(data.args_atoms[1]) or 1
-        nmemb = state.get_concrete_value(data.args_atoms[1]) or 2
+        nmemb = state.get_concrete_value(data.args_atoms[2]) or 2
         dst_atom = state.deref(data.args_atoms[0], size * nmemb)
         data.depends(dst_atom, StdinAtom("fread", size * nmemb))
 
     @FunctionCallDataUnwrapped.decorate
     def handle_impl_fwrite(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         size = state.get_concrete_value(data.args_atoms[1]) or 1
-        nmemb = state.get_concrete_value(data.args_atoms[1]) or 2
+        nmemb = state.get_concrete_value(data.args_atoms[2]) or 2
         src_atom = state.deref(data.args_atoms[0], size * nmemb)
         data.depends(StdoutAtom("fwrite", size * nmemb), src_atom, value=state.get_values(src_atom))
 
@@ -206,8 +206,8 @@ def handle_printf(
         elif fmt == "%u":
             buf_atoms = atom
             buf_data = state.get_concrete_value(buf_atoms)
-            if buf_data is not None:
-                buf_data = str(buf_data).encode()
+            buf_data = str(buf_data).encode() if buf_data else b"0"
+
         elif fmt == "%d":
             buf_atoms = atom
             buf_data = state.get_concrete_value(buf_atoms)
@@ -215,11 +215,12 @@ def handle_printf(
                 if buf_data >= 2**31:
                     buf_data -= 2**32
                 buf_data = str(buf_data).encode()
+            else:
+                buf_data = b"0"
         elif fmt == "%c":
             buf_atoms = atom
             buf_data = state.get_concrete_value(atom)
-            if buf_data is not None:
-                buf_data = chr(buf_data).encode()
+            buf_data = chr(buf_data).encode() if buf_data else b"0"
         else:
             _l.warning("Unimplemented printf format string %s", fmt)
             buf_atoms = set()

angr/analyses/reaching_definitions/function_handler_library/stdlib.py

@@ -64,21 +64,25 @@ class LibcStdlibHandlers(FunctionHandler):
                 buf_value = int(buf_value.decode().strip("\0"))
             except ValueError:
                 buf_value = 0
+        else:
+            buf_value = 0  # Make the value concrete if it cannot be parsed
         data.depends(data.ret_atoms, buf_atoms, value=buf_value)
 
     @FunctionCallDataUnwrapped.decorate
     def handle_impl_malloc(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         malloc_size = state.get_concrete_value(data.args_atoms[0]) or 48
         heap_ptr = state.heap_allocator.allocate(malloc_size)
-        data.depends(data.ret_atoms, value=state.heap_address(heap_ptr))
+        heap_addr = state.heap_address(heap_ptr)
+        data.depends(data.ret_atoms, value=heap_addr)
 
     @FunctionCallDataUnwrapped.decorate
     def handle_impl_calloc(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         nmemb = state.get_concrete_value(data.args_atoms[0]) or 48
         size = state.get_concrete_value(data.args_atoms[1]) or 1
-        heap_ptr = state.heap_address(state.heap_allocator.allocate(nmemb * size))
-        data.depends(state.deref(heap_ptr, nmemb * size), value=0)
-        data.depends(data.ret_atoms, value=heap_ptr)
+        heap_ptr = state.heap_allocator.allocate(nmemb * size)
+        heap_addr = state.heap_address(heap_ptr)
+        data.depends(state.deref(heap_addr, nmemb * size), value=0)
+        data.depends(data.ret_atoms, value=heap_addr)
 
     @FunctionCallDataUnwrapped.decorate
     def handle_impl_getenv(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
@@ -156,6 +160,8 @@ class LibcStdlibHandlers(FunctionHandler):
     def handle_impl_execve(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         argv_value = state.get_one_value(data.args_atoms[1])
         if argv_value is None:
+            # Model execve with unknown argv - still has system effects
+            data.depends(SystemAtom(1), data.args_atoms[0], value=state.get_values(data.args_atoms[0]))
             return
 
         nonce = random.randint(1, 999999999)

angr/analyses/reaching_definitions/function_handler_library/string.py

@@ -30,7 +30,7 @@ class LibcStringHandlers(FunctionHandler):
             dest_value = src0_value.concat(MultiValues(top_val))
             dest_atom = state.deref(data.args_atoms[0], len(dest_value) // 8, endness=archinfo.Endness.BE)
         else:
-            dest_value = None
+            dest_value = state.top(state.arch.bits)
             dest_atom = src0_atom
         if src0_atom is not None and src1_atom is not None:
             data.depends(dest_atom, src0_atom, src1_atom, value=dest_value)
@@ -109,7 +109,8 @@ class LibcStringHandlers(FunctionHandler):
             src_str = state.get_values(src_atom)
             malloc_size = len(src_str) // 8 if src_str is not None else 1
             heap_ptr = state.heap_allocator.allocate(malloc_size)
-            dst_atom = state.deref(heap_ptr, malloc_size)
+            heap_addr = state.heap_address(heap_ptr)
+            dst_atom = state.deref(heap_addr, malloc_size)
             data.depends(dst_atom, src_atom, value=src_str)
         data.depends(data.ret_atoms, data.args_atoms[0], value=state.get_values(data.args_atoms[0]))
 
@@ -121,6 +122,16 @@ class LibcStringHandlers(FunctionHandler):
             dst_atom = state.deref(data.args_atoms[0], size)
             if src_atom is not None:
                 data.depends(dst_atom, src_atom, value=state.get_values(src_atom))
+        else:
+            # When size is unknown, use default size and create TOP value
+            default_size = state.arch.bytes
+            src_atom = state.deref(data.args_atoms[1], default_size)
+            dst_atom = state.deref(data.args_atoms[0], default_size)
+            if src_atom is not None:
+                top_val = state.top(default_size * 8)
+                for defn in state.get_definitions(src_atom):
+                    top_val = state.annotate_with_def(top_val, defn)
+                data.depends(dst_atom, src_atom, value=MultiValues(top_val))
         data.depends(data.ret_atoms, data.args_atoms[0], value=state.get_values(data.args_atoms[0]))
 
     @FunctionCallDataUnwrapped.decorate

angr/analyses/reaching_definitions/function_handler_library/unistd.py

@@ -32,6 +32,9 @@ class LibcUnistdHandlers(FunctionHandler):
         buf_data = state.top(size * 8) if size is not None else state.top(state.arch.bits)
 
         data.depends(dst_atom, fd_atom, value=buf_data)
+        # Model return value - number of bytes read (could be 0 to size, or -1 for error)
+        ret_val = state.top(state.arch.bits)  # Unknown number of bytes read
+        data.depends(data.ret_atoms, fd_atom, value=ret_val)
 
     handle_impl_recv = handle_impl_recvfrom = handle_impl_read
 
@@ -41,4 +44,8 @@ class LibcUnistdHandlers(FunctionHandler):
         src_atom = state.deref(data.args_atoms[1], size)
         data.depends(StdoutAtom(data.function.name, size), src_atom, value=state.get_values(src_atom))
 
+        # Model return value - number of bytes written (could be 0 to size, or -1 for error)
+        ret_val = state.top(state.arch.bits)  # Unknown number of bytes written
+        data.depends(data.ret_atoms, value=ret_val)
+
     handle_impl_send = handle_impl_write

angr/analyses/s_propagator.py

@@ -33,7 +33,7 @@ from angr.utils.ssa import (
     is_const_vvar_load_assignment,
     is_const_vvar_load_dirty_assignment,
     is_const_vvar_tmp_assignment,
-    is_vvar_eliminatable,
+    is_vvar_propagatable,
     get_tmp_uselocs,
     get_tmp_deflocs,
     phi_assignment_get_src,
@@ -246,7 +246,7 @@ class SPropagatorAnalysis(Analysis):
                         self.model.dead_vvar_ids.add(vvar.varid)
                         continue
 
-                if is_vvar_eliminatable(vvar, stmt):
+                if is_vvar_propagatable(vvar, stmt):
                     if len(vvar_uselocs_set) == 1:
                         vvar_used, vvar_useloc = next(iter(vvar_uselocs_set))
                         if (

angr/analyses/variable_recovery/engine_base.py

@@ -142,6 +142,8 @@ class SimEngineVRBase(
     ) -> list[tuple[SimVariable, int]]:
         data = richr_addr.data
 
+        variable: SimVariable | None = None
+
         if self.state.is_stack_address(data):
             # this is a stack address
             # extract stack offset
@@ -157,7 +159,6 @@ class SimEngineVRBase(
             for candidate, offset in var_candidates:
                 if isinstance(candidate, SimStackVariable) and candidate.offset == stack_offset:
                     existing_vars.append((candidate, offset))
-            variable = None
             if existing_vars:
                 variable, _ = existing_vars[0]
 
@@ -178,6 +179,9 @@ class SimEngineVRBase(
                                 for var_stack_offset, var in self.state.extract_variables(v):
                                     existing_vars.append((var, var_stack_offset))
 
+                    if not existing_vars:
+                        existing_vars = [(v, 0) for v in variable_manager.find_variables_by_stack_offset(stack_offset)]
+
                     if not existing_vars:
                         # no variables exist
                         lea_size = 1
@@ -185,10 +189,10 @@ class SimEngineVRBase(
                             stack_offset,
                             lea_size,
                             base="bp",
-                            ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
+                            ident=variable_manager.next_variable_ident("stack"),
                             region=self.func_addr,
                         )
-                        self.state.variable_manager[self.func_addr].add_variable("stack", stack_offset, variable)
+                        variable_manager.add_variable("stack", stack_offset, variable)
                         l.debug("Identified a new stack variable %s at %#x.", variable, self.ins_addr)
                         existing_vars.append((variable, 0))
 
@@ -555,7 +559,7 @@ class SimEngineVRBase(
 
         if isinstance(stack_offset, int):
             expr = data.data
-            if isinstance(expr, claripy.ast.Bits) and expr.size() > 1024:
+            if isinstance(expr, claripy.ast.BV) and expr.size() > 1024:
                 # we don't write more than 256 bytes to the stack at a time for performance reasons
                 expr = expr[expr.size() - 1 : expr.size() - 1024]
             expr = self.state.annotate_with_variables(expr, [(variable_offset, variable)])

angr/knowledge_plugins/functions/function.py

@@ -1666,7 +1666,7 @@ class Function(Serializable):
         if self.is_rust_function():
             ast = pydemumble.demangle(self.name)
             return Function._rust_fmt_node(ast.split("::")[-2])
-        func_name = get_cpp_function_name(self.demangled_name, specialized=False, qualified=True)
+        func_name = get_cpp_function_name(self.demangled_name)
         return func_name.split("::")[-1]
 
     def get_unambiguous_name(self, display_name: str | None = None) -> str:

angr/knowledge_plugins/functions/function_manager.py

@@ -154,8 +154,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         :return:            None
         """
         with open(filepath, "w", encoding="utf-8") as f:
-            for src, dst in self.callgraph.edges():
-                f.write(f"{src:#x}\tDirectEdge\t{dst:#x}\n")
+            f.writelines(f"{src:#x}\tDirectEdge\t{dst:#x}\n" for src, dst in self.callgraph.edges())
 
     def _addr_in_plt_cached_ranges(self, addr: int) -> bool:
         if self._rplt_cache_ranges is None:

angr/project.py

@@ -32,7 +32,10 @@ def load_shellcode(shellcode: bytes | str, arch, start_offset=0, load_address=0,
     if not isinstance(arch, archinfo.Arch):
         arch = archinfo.arch_from_id(arch)
     if isinstance(shellcode, str):
-        shellcode_bytes: bytes = arch.asm(shellcode, load_address, thumb=thumb)
+        shellcode_bytes = arch.asm(shellcode, load_address, thumb=thumb)
+        if shellcode_bytes is None:
+            raise ValueError("Could not assemble shellcode")
+        assert isinstance(shellcode_bytes, bytes)
     else:
         shellcode_bytes = shellcode
     if thumb:
@@ -173,7 +176,7 @@ class Project:
 
         # It doesn't make any sense to have auto_load_libs
         # if you have the concrete target, let's warn the user about this.
-        if self.concrete_target and load_options.get("auto_load_libs", None):
+        if self.concrete_target and load_options.get("auto_load_libs"):
             l.critical(
                 "Incompatible options selected for this project, please disable auto_load_libs if "
                 "you want to use a concrete target."

angr/sim_type.py

@@ -3342,7 +3342,7 @@ def _decl_to_type(
 
         if decl.name is not None:
             key = "struct " + decl.name
-            struct = extra_types.get(key, None)
+            struct = extra_types.get(key)
             from_global = False
             if struct is None:
                 struct = ALL_TYPES.get(key)
@@ -3378,7 +3378,7 @@ def _decl_to_type(
 
         if decl.name is not None:
             key = "union " + decl.name
-            union = extra_types.get(key, None)
+            union = extra_types.get(key)
             from_global = False
             if union is None and key in ALL_TYPES:
                 union = ALL_TYPES[key]

angr/simos/javavm.py

@@ -255,7 +255,7 @@ class SimJavaVM(SimOS):
                     upper = native_arg_value.get_bytes(0, 4)
                     lower = native_arg_value.get_bytes(4, 4)
                     idx = args.index(arg)
-                    args = args[:idx] + (SootArgument(upper, "int"), SootArgument(lower, "int")) + args[idx + 1 :]
+                    args = (*args[:idx], SootArgument(upper, "int"), SootArgument(lower, "int"), *args[idx + 1 :])
                     native_arg_values += [upper, lower]
                     continue
                 if type(arg.value) is BV and len(arg.value) > arg_ty.size:

angr/utils/graph.py

@@ -55,7 +55,7 @@ def inverted_idoms(graph: networkx.DiGraph) -> tuple[networkx.DiGraph, dict | No
 
 
 def to_acyclic_graph(
-    graph: networkx.DiGraph, ordered_nodes: list | None = None, loop_heads: list | None = None
+    graph: networkx.DiGraph, node_order: dict[Any, int] | None = None, loop_heads: list | None = None
 ) -> networkx.DiGraph:
     """
     Convert a given DiGraph into an acyclic graph.
@@ -66,21 +66,22 @@ def to_acyclic_graph(
     :return:                The converted acyclic graph.
     """
 
-    if ordered_nodes is None:
+    if node_order is None:
         # take the quasi-topological order of the graph
         ordered_nodes = GraphUtils.quasi_topological_sort_nodes(graph, loop_heads=loop_heads)
-
-    acyclic_graph = networkx.DiGraph()
+        node_order = {n: i for i, n in enumerate(ordered_nodes)}
 
     # add each node and its edge into the graph
-    visited = set()
-    for node in ordered_nodes:
-        visited.add(node)
-        acyclic_graph.add_node(node)
-        for successor in graph.successors(node):
-            if successor not in visited:
-                acyclic_graph.add_edge(node, successor)
-
+    edges_to_remove = []
+    for src, dst in graph.edges():
+        src_order = node_order[src]
+        dst_order = node_order[dst]
+        if src_order > dst_order:
+            # this is a back edge, we need to remove it
+            edges_to_remove.append((src, dst))
+
+    acyclic_graph = graph.copy()
+    acyclic_graph.remove_edges_from(edges_to_remove)
     return acyclic_graph
 
 
@@ -672,6 +673,21 @@ class GraphUtils:
 
         return list(widening_addrs)
 
+    @staticmethod
+    def dfs_postorder_nodes_deterministic(graph: networkx.DiGraph, source):
+        visited = set()
+        stack = [source]
+        while stack:
+            node = stack[-1]
+            if node not in visited:
+                visited.add(node)
+                for succ in sorted(graph.successors(node), key=GraphUtils._sort_node):
+                    if succ not in visited:
+                        stack.append(succ)
+            else:
+                yield node
+                stack.pop()
+
     @staticmethod
     def reverse_post_order_sort_nodes(graph, nodes=None):
         """

angr/utils/library.py

@@ -168,7 +168,7 @@ def parsedcprotos2py(
                 proto_.returnty = SimTypeFd(label=proto_.returnty.label)
             for i, arg in enumerate(proto_.args):
                 if (func_name, i) in fd_spots:
-                    proto_.args = proto_.args[:i] + (SimTypeFd(label=arg.label),) + proto_.args[i + 1 :]
+                    proto_.args = (*proto_.args[:i], SimTypeFd(label=arg.label), *proto_.args[i + 1 :])
 
         line1 = " " * 8 + "#" + ((" " + decl) if decl else "") + "\n"
         line2 = " " * 8 + repr(func_name) + ": " + (proto_._init_str() if proto_ is not None else "None") + "," + "\n"
@@ -195,17 +195,18 @@ def cprotos2py(cprotos: list[str], fd_spots=frozenset(), remove_sys_prefix=False
     return parsedcprotos2py(parsed_cprotos, fd_spots=fd_spots, remove_sys_prefix=remove_sys_prefix)
 
 
-def get_cpp_function_name(demangled_name, specialized=True, qualified=True):
-    # remove "<???>"s
-    name = normalize_cpp_function_name(demangled_name) if not specialized else demangled_name
+def get_cpp_function_name(demangled_name: str) -> str:
+    """
+    Parse a demangled C++ declaration into a function name.
 
-    if not qualified:
-        # remove leading namespaces
-        chunks = name.split("::")
-        name = "::".join(chunks[2:])
+    Note that the extracted name may include template instantiation, for example:
 
-    # remove arguments
-    if "(" in name:
-        name = name[: name.find("(")]
+        example_func<int>
 
-    return name
+    :param demangled_name: The demangled C++ function name.
+    :return:               The qualified function name, excluding return type and parameters.
+    """
+    func_decls, _ = parse_cpp_file(demangled_name)
+    if func_decls and len(func_decls) == 1:
+        return next(iter(func_decls))
+    return normalize_cpp_function_name(demangled_name)

angr/utils/ssa/__init__.py

@@ -6,7 +6,7 @@ from typing import Any, Literal, overload
 import networkx
 
 import archinfo
-from angr.ailment import Expression, Block
+from angr.ailment import Expression, Block, UnaryOp
 from angr.ailment.expression import (
     VirtualVariable,
     Const,
@@ -42,7 +42,7 @@ def get_reg_offset_base_and_size(
 
 def get_reg_offset_base_and_size(
     reg_offset: int, arch: archinfo.Arch, size: int | None = None, resilient: bool = True
-) -> tuple[int, int] | None:
+) -> tuple[int, int | None] | None:
     """
     Translate a given register offset into the offset of its full register and obtain the size of the full register.
 
@@ -278,6 +278,31 @@ def has_tmp_expr(expr: Expression) -> bool:
     return walker.has_blacklisted_exprs
 
 
+class AILReferenceFinder(AILBlockWalkerBase):
+    """
+    Walks an AIL expression or statement and finds if it contains references to certain expressions.
+    """
+
+    def __init__(self, vvar_id: int):
+        super().__init__()
+        self.vvar_id = vvar_id
+        self.has_references_to_vvar = False
+
+    def _handle_UnaryOp(
+        self, expr_idx: int, expr: UnaryOp, stmt_idx: int, stmt: Statement | None, block: Block | None
+    ) -> Any:
+        if expr.op == "Reference" and isinstance(expr.operand, VirtualVariable) and expr.operand.varid == self.vvar_id:
+            self.has_references_to_vvar = True
+            return None
+        return super()._handle_UnaryOp(expr_idx, expr, stmt_idx, stmt, block)
+
+
+def has_reference_to_vvar(stmt: Statement, vvar_id: int) -> bool:
+    walker = AILReferenceFinder(vvar_id)
+    walker.walk_statement(stmt)
+    return walker.has_references_to_vvar
+
+
 def check_in_between_stmts(
     graph: networkx.DiGraph,
     blocks: dict[tuple[int, int | None], Block],
@@ -358,6 +383,33 @@ def has_load_expr_in_between_stmts(
     )
 
 
+def is_vvar_propagatable(vvar: VirtualVariable, def_stmt: Statement | None) -> bool:
+    if vvar.was_tmp or vvar.was_reg or vvar.was_parameter:
+        return True
+    if vvar.was_stack and isinstance(def_stmt, Assignment):
+        if isinstance(def_stmt.src, Const):
+            return True
+        if (
+            isinstance(def_stmt.src, VirtualVariable)
+            and def_stmt.src.was_stack
+            and def_stmt.src.stack_offset == vvar.stack_offset
+        ):
+            # special case: the following block
+            #   ## Block 401e98
+            #   00 | 0x401e98 | LABEL_401e98:
+            #   01 | 0x401e98 | vvar_227{stack -12} = 𝜙@32b [((4202088, None), vvar_277{stack -12}), ((4202076, None),
+            #                   vvar_278{stack -12})]
+            #   02 | 0x401ea0 | return Conv(32->64, vvar_227{stack -12});
+            # might be simplified to the following block after return duplication
+            #   ## Block 401e98.1
+            #   00 | 0x401e98 | LABEL_401e98__1:
+            #   01 | 0x401e98 | vvar_279{stack -12} = vvar_277{stack -12}
+            #   02 | 0x401ea0 | return Conv(32->64, vvar_279{stack -12});
+            # in this case, vvar_279 is eliminatable.
+            return True
+    return False
+
+
 def is_vvar_eliminatable(vvar: VirtualVariable, def_stmt: Statement | None) -> bool:
     if vvar.was_tmp or vvar.was_reg or vvar.was_parameter:
         return True

{angr-9.2.161.dist-info → angr-9.2.163.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.161
+Version: 9.2.163
 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.161
+Requires-Dist: archinfo==9.2.163
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.161
-Requires-Dist: cle==9.2.161
+Requires-Dist: claripy==9.2.163
+Requires-Dist: cle==9.2.163
 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.161
+Requires-Dist: pyvex==9.2.163
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy