angr 9.2.119__py3-none-macosx_11_0_arm64.whl → 9.2.121__py3-none-macosx_11_0_arm64.whl

angr/knowledge_plugins/sync/sync_controller.py

@@ -1,324 +0,0 @@
-# pylint:disable=import-outside-toplevel
-from __future__ import annotations
-from functools import wraps
-
-from ... import knowledge_plugins
-from ...knowledge_plugins.plugin import KnowledgeBasePlugin
-from ...sim_variable import SimStackVariable
-from ..variables.variable_manager import VariableManagerInternal
-
-binsync_available = None
-binsync = None
-Client = None
-StackVariable = None
-StackOffsetType = None
-
-
-def import_binsync():
-    global binsync
-    global binsync_available
-    try:
-        import binsync
-
-        binsync_available = True
-    except ImportError:
-        binsync_available = False
-
-
-def make_state(f):
-    """
-    Build a writeable State instance and pass to `f` as the `state` kwarg if the `state` kwarg is None.
-    Function `f` should have have at least two kwargs, `user` and `state`.
-    """
-
-    @wraps(f)
-    def state_check(self, *args, **kwargs):
-        state = kwargs.pop("state", None)
-        user = kwargs.pop("user", None)
-        if state is None:
-            state = self.client.get_state(user=user)
-            kwargs["state"] = state
-            r = f(self, *args, **kwargs)
-            state.save()
-            return r
-        kwargs["state"] = state
-        return f(self, *args, **kwargs)
-
-    return state_check
-
-
-def make_ro_state(f):
-    """
-    Build a read-only State instance and pass to `f` as the `state` kwarg if the `state` kwarg is None.
-    Function `f` should have have at least two kwargs, `user` and `state`.
-    """
-
-    @wraps(f)
-    def state_check(self, *args, **kwargs):
-        state = kwargs.pop("state", None)
-        user = kwargs.pop("user", None)
-        if state is None:
-            state = self.client.get_state(user=user)
-        kwargs["state"] = state
-        kwargs["user"] = user
-        return f(self, *args, **kwargs)
-
-    return state_check
-
-
-def init_checker(f):
-    @wraps(f)
-    def initcheck(self, *args, **kwargs):
-        if self.client is None:
-            raise ValueError("Please initialize SyncController by calling initialize(client).")
-        return f(self, *args, **kwargs)
-
-    return initcheck
-
-
-class SyncController(KnowledgeBasePlugin):
-    """
-    SyncController interfaces with a binsync client to push changes upwards and pull changes downwards.
-
-    :ivar binsync.Client client:   The binsync client.
-    """
-
-    def __init__(self, kb):
-        # import binsync upon the first use of this class
-        import_binsync()
-
-        super().__init__(kb=kb)
-
-        self.client: binsync.client.Client | None = None
-
-    #
-    # Public methods
-    #
-
-    def connect(
-        self, user, path, bin_hash="", init_repo=False, ssh_agent_pid=None, ssh_auth_sock=None, remote_url=None
-    ):
-        self.client = Client(
-            user,
-            path,
-            bin_hash,
-            init_repo=init_repo,
-            ssh_agent_pid=ssh_agent_pid,
-            ssh_auth_sock=ssh_auth_sock,
-            remote_url=remote_url,
-        )
-
-    @property
-    def connected(self):
-        return self.client is not None
-
-    def commit(self):
-        self.client.save_state()
-
-    def update(self):
-        self.client.update()
-
-    def copy(self):
-        raise NotImplementedError
-
-    def pull(self):
-        return self.client.pull()
-
-    @property
-    def has_remote(self):
-        return self.client.has_remote
-
-    @init_checker
-    def users(self):
-        return self.client.users()
-
-    @init_checker
-    def status(self):
-        return self.client.status()
-
-    def tally(self, users=None):
-        return self.client.tally(users=users)
-
-    #
-    # Pushers
-    #
-
-    @init_checker
-    @make_state
-    # pylint:disable=unused-argument,no-self-use
-    def push_function(self, func: knowledge_plugins.Function, user=None, state=None):
-        """
-        Push a function upwards.
-
-        :param Function func:   The angr Function object to push upwards.
-        :return:                True if updates are made. False otherwise.
-        :rtype:                 bool
-        """
-
-        _func = binsync.data.Function(func.addr, name=func.name, notes=None)
-        return state.set_function(_func)
-
-    @init_checker
-    @make_state
-    # pylint:disable=unused-argument,no-self-use
-    def push_comment(self, addr, comment, decompiled=False, user=None, state=None):
-        func_addr = self.get_func_addr_from_addr(addr)
-        sync_cmt = binsync.data.Comment(func_addr, addr, comment, decompiled)
-
-        return state.set_comment(sync_cmt)
-
-    @init_checker
-    @make_state
-    # pylint:disable=unused-argument,no-self-use
-    def push_comments(self, comments: list[binsync.data.Comment], user=None, state=None):
-        """
-        Push a bunch of comments upwards.
-
-        :param list comments:   A list of BinSync Comments
-        :return:                bool
-        """
-
-        r = True
-        for cmt in comments:
-            r &= state.set_comment(cmt)
-        return r
-
-    @init_checker
-    @make_state
-    # pylint:disable=unused-argument,no-self-use
-    def push_stack_variables(
-        self, stack_variables: list[SimStackVariable], var_manager: VariableManagerInternal, user=None, state=None
-    ):
-        """
-
-        :param stack_variables:
-        :param var_manager:
-        :return:
-        """
-        r = True
-        for var in stack_variables:
-            guessed_var_type = var_manager.get_variable_type(var)
-            var_type = guessed_var_type if guessed_var_type else "BOT"
-
-            # construct a StackVariable for each SimStackVariable
-            sync_stack_var = StackVariable(
-                var.offset, StackOffsetType.ANGR, var.name, var_type, var.size, var_manager.func_addr
-            )
-
-            r &= state.set_stack_variable(sync_stack_var, var.offset, var_manager.func_addr)
-
-        # return true only if all pushed worked
-        return r
-
-    @init_checker
-    @make_state
-    # pylint:disable=unused-argument,no-self-use
-    def push_stack_variable(self, func_addr, offset, name, type_, size_, user=None, state=None):
-        sync_var = StackVariable(offset, StackOffsetType.ANGR, name, type_, size_, func_addr)
-        return state.set_stack_variable(sync_var, offset, func_addr)
-
-    #
-    # Pullers
-    #
-
-    @init_checker
-    @make_ro_state
-    # pylint:disable=unused-argument
-    def pull_function(self, addr, user=None, state=None) -> binsync.data.Function | None:
-        """
-        Pull a function downwards.
-
-        :param int addr:    Address of the function.
-        :param str user:    Name of the user.
-        :return:            The binsync.data.Function object if pulling succeeds, or None if pulling fails.
-        """
-
-        func_addr = self.get_func_addr_from_addr(addr)
-        try:
-            return state.get_function(func_addr)
-        except KeyError:
-            return None
-
-    @init_checker
-    @make_ro_state
-    # pylint:disable=unused-argument
-    def pull_comment(self, addr, user=None, state=None) -> binsync.data.Comment | None:
-        """
-        Pull a comment downwards.
-
-        :param int addr:    Address of the comment.
-        :param str user:    Name of the user.
-        :return:            a Comment object from BinSync, or None
-        """
-
-        func_addr = self.get_func_addr_from_addr(addr)
-        try:
-            return state.get_comment(func_addr, addr)
-        except KeyError:
-            return None
-
-    @init_checker
-    @make_ro_state
-    # pylint:disable=unused-argument,no-self-use
-    def pull_comments(self, func_addr, user=None, state=None):
-        """
-        Pull comments downwards.
-
-        :param int start_addr:  Where we want to pull comments.
-        :param int end_addr:    Where we want to stop pulling comments (exclusive).
-        :return:                An iterator.
-        :rtype:                 Iterable
-        """
-        try:
-            return state.get_comments(func_addr)
-        except KeyError:
-            return {}
-
-    @init_checker
-    @make_ro_state
-    # pylint:disable=unused-argument,no-self-use
-    def pull_patches(self, user=None, state=None):
-        """
-        Pull patches.
-
-        :param str user:    Name of the user to patches from.
-        :return:            An iterator
-        :rtype:             Iterable
-        """
-
-        return state.get_state(user=user).get_patches()
-
-    @init_checker
-    @make_ro_state
-    # pylint:disable=unused-argument,no-self-use
-    def pull_stack_variables(self, func_addr, user=None, state=None):
-        """
-        Pull stack variables from a function.
-
-        @param func_addr:   Function address to pull from
-        @param user:
-        @param state:
-        @return:
-        """
-        try:
-            stack_vars = state.get_stack_variables(func_addr)
-        except KeyError:
-            stack_vars = {}
-
-        return stack_vars
-
-    #
-    #   Utils
-    #
-
-    def get_func_addr_from_addr(self, addr):
-        try:
-            func_addr = self._kb.cfgs.get_most_accurate().get_any_node(addr, anyaddr=True).function_address
-        except AttributeError:
-            func_addr = -1
-
-        return func_addr
-
-
-if binsync_available:
-    KnowledgeBasePlugin.register_default("sync", SyncController)

angr/misc/range.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-
-class IRange:
-    """
-    A simple range object for testing inclusion. Like range but works for huge numbers.
-    """
-
-    __slots__ = ("start", "end")
-
-    def __init__(self, start, end):
-        self.start = start
-        self.end = end
-
-    def __contains__(self, k):
-        if type(k) is int:
-            return k >= self.start and k < self.end
-        return False
-
-    def __getstate__(self):
-        return self.start, self.end
-
-    def __setstate__(self, state):
-        self.start, self.end = state

angr/misc/weakpatch.py

@@ -1,59 +0,0 @@
-from __future__ import annotations
-from weakref import WeakValueDictionary, WeakKeyDictionary, _IterationGuard
-
-
-def copy_wvd(self):
-    if self._pending_removals:
-        self._commit_removals()
-    new = WeakValueDictionary()
-    with _IterationGuard(self):
-        for key, wr in self.data.items():
-            o = wr()
-            if o is not None:
-                new[key] = o
-    return new
-
-
-def deepcopy_wvd(self, memo):
-    from copy import deepcopy
-
-    if self._pending_removals:
-        self._commit_removals()
-    new = self.__class__()
-    with _IterationGuard(self):
-        for key, wr in self.data.items():
-            o = wr()
-            if o is not None:
-                new[deepcopy(key, memo)] = o
-    return new
-
-
-def copy_wkd(self):
-    new = WeakKeyDictionary()
-    with _IterationGuard(self):
-        for key, value in self.data.items():
-            o = key()
-            if o is not None:
-                new[o] = value
-    return new
-
-
-def deepcopy_wkd(self, memo):
-    from copy import deepcopy
-
-    new = self.__class__()
-    with _IterationGuard(self):
-        for key, value in self.data.items():
-            o = key()
-            if o is not None:
-                new[o] = deepcopy(value, memo)
-    return new
-
-
-WeakValueDictionary.copy = copy_wvd
-WeakValueDictionary.__copy__ = copy_wvd
-WeakValueDictionary.__deepcopy__ = deepcopy_wvd
-
-WeakKeyDictionary.copy = copy_wkd
-WeakKeyDictionary.__copy__ = copy_wkd
-WeakKeyDictionary.__deepcopy__ = deepcopy_wkd

angr/storage/memory_mixins/javavm_memory/__init__.py

@@ -1,2 +0,0 @@
-from __future__ import annotations
-from .javavm_memory_mixin import JavaVmMemoryMixin

angr/storage/memory_mixins/keyvalue_memory/__init__.py

@@ -1,2 +0,0 @@
-from __future__ import annotations
-from .keyvalue_memory_mixin import KeyValueMemoryMixin

angr/storage/pcap.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-import socket
-import logging
-
-import dpkt
-
-l = logging.getLogger(name=__name__)
-
-
-class PCAP:
-    def __init__(self, path, ip_port_tup, init=True):
-        self.path = path
-        self.packet_num = 0
-        self.pos = 0
-        self.in_streams = []
-        self.out_streams = []
-        self.ip = ip_port_tup[0]
-        self.port = ip_port_tup[1]
-        if init:
-            self.initialize(self.path)
-
-    def initialize(self, path):
-        with open(path) as f:
-            pcap = dpkt.pcap.Reader(f)
-        for _, buf in pcap:
-            ip = dpkt.ethernet.Ethernet(buf).ip
-            tcp = ip.data
-            myip = socket.inet_ntoa(ip.dst)
-            if myip is self.ip and tcp.dport is self.port and len(tcp.data) != 0:
-                self.out_streams.append((len(tcp.data), tcp.data))
-            elif len(tcp.data) != 0:
-                self.in_streams.append((len(tcp.data), tcp.data))
-
-    def recv(self, length):
-        temp = 0
-        initial_packet = self.packet_num
-        plength, pdata = self.in_streams[self.packet_num]
-        length = min(length, plength)
-        if self.pos == 0:
-            if plength > length:
-                temp = length
-            else:
-                self.packet_num += 1
-
-            packet_data = pdata[self.pos : length]
-            self.pos += temp
-        else:
-            if (self.pos + length) >= plength:
-                rest = plength - self.pos
-                length = rest
-                self.packet_num += 1
-
-            packet_data = pdata[self.pos : plength]
-
-        if self.packet_num is not initial_packet:
-            self.pos = 0
-        return packet_data, length
-
-    def copy(self):
-        new_pcap = PCAP(self.path, (self.ip, self.port), init=False)
-        new_pcap.packet_num = self.packet_num
-        new_pcap.pos = self.pos
-        new_pcap.in_streams = self.in_streams
-        new_pcap.out_streams = self.out_streams
-        return new_pcap

angr/utils/typing.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-from typing import TypeVar
-from collections.abc import Iterable
-
-_T = TypeVar("_T")
-
-
-def unwrap(thing: _T | None) -> _T:
-    assert thing is not None, "Tried to unwrap a `None` value"
-    return thing
-
-
-def one(thing: Iterable[_T]) -> _T:
-    try:
-        (result,) = thing
-    except ValueError as e:
-        raise AssertionError("Tried to get only value of an iterable with some other number of items") from e
-    return result