dissect.target 3.20.dev5__tar.gz → 3.20.dev6__tar.gz

{dissect_target-3.20.dev5/dissect.target.egg-info → dissect_target-3.20.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.20.dev5
+Version: 3.20.dev6
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/dissect/target/loader.py

@@ -177,7 +177,6 @@ def open(item: Union[str, Path], *args, **kwargs) -> Loader:
 register("local", "LocalLoader")
 register("remote", "RemoteLoader")
 register("mqtt", "MQTTLoader")
-register("targetd", "TargetdLoader")
 register("asdf", "AsdfLoader")
 register("tar", "TarLoader")
 register("vmx", "VmxLoader")

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/dissect/target/loaders/mqtt.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import argparse
 import atexit
 import logging
 import math
 import os
+import re
 import ssl
 import sys
 import time
@@ -280,7 +282,7 @@ class Broker:
     factor = 1
 
     def __init__(
-        self, broker: Broker, port: str, key: str, crt: str, ca: str, case: str, username: str, password: str, **kwargs
+        self, broker: str, port: str, key: str, crt: str, ca: str, case: str, username: str, password: str, **kwargs
     ):
         self.broker_host = broker
         self.broker_port = int(port)
@@ -352,8 +354,7 @@ class Broker:
             log.error(f"Failed to decode payload for hostname {hostname}: {e}")
             return
 
-        # The payload with the username and password is comma separated
-        print(f'"{hostname}",{decoded_payload}')
+        print(decoded_payload)
 
     def _on_log(self, client: mqtt.Client, userdata: Any, log_level: int, message: str) -> None:
         log.debug(message)
@@ -423,16 +424,97 @@ class Broker:
         self.mqtt_client.loop_start()
 
 
-@arg("--mqtt-peers", type=int, dest="peers", help="minimum number of peers to await for first alias")
-@arg("--mqtt-case", dest="case", help="case name (broker will determine if you are allowed to access this data)")
-@arg("--mqtt-port", type=int, dest="port", help="broker connection port")
-@arg("--mqtt-broker", dest="broker", help="broker ip-address")
-@arg("--mqtt-key", dest="key", help="private key file")
-@arg("--mqtt-crt", dest="crt", help="client certificate file")
-@arg("--mqtt-ca", dest="ca", help="certificate authority file")
+def strictly_positive(value: str) -> int:
+    """
+    Validates that the provided value is a strictly positive integer.
+
+    This function is intended to be used as a type for argparse arguments.
+
+    Args:
+        value (str): The value to validate.
+
+    Returns:
+        int: The validated integer value.
+
+    Raises:
+        argparse.ArgumentTypeError: If the value is not a strictly positive integer.
+    """
+    try:
+        strictly_positive_value = int(value)
+        if strictly_positive_value < 1:
+            raise argparse.ArgumentTypeError("Value must be larger than or equal to 1.")
+        return strictly_positive_value
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"Invalid integer value specified: '{value}'")
+
+
+def port(value: str) -> int:
+    """
+    Convert a string value to an integer representing a valid port number.
+
+    This function is intended to be used as a type for argparse arguments.
+
+    Args:
+        value (str): The string representation of the port number.
+    Returns:
+        int: The port number as an integer.
+    Raises:
+        argparse.ArgumentTypeError: If the port number is not an integer or out of the valid range (1-65535).
+    """
+
+    try:
+        port = int(value)
+        if port < 1 or port > 65535:
+            raise argparse.ArgumentTypeError("Port number must be between 1 and 65535.")
+        return port
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"Invalid port number specified: '{value}'")
+
+
+def case(value: str) -> str:
+    """
+    Validates that the given value is a valid case name consisting of
+    alphanumeric characters and underscores only.
+
+    This function is intended to be used as a type for argparse arguments.
+
+    Args:
+        value (str): The case name to validate.
+
+    Returns:
+        str: The validated case name if it matches the required pattern.
+
+    Raises:
+        argparse.ArgumentTypeError: If the case name does not match the required pattern.
+    """
+
+    if re.match(r"^[a-zA-Z0-9_]+$", value):
+        return value
+
+    raise argparse.ArgumentTypeError(f"Invalid case name specified: '{value}'")
+
+
+@arg(
+    "--mqtt-peers",
+    type=strictly_positive,
+    dest="peers",
+    default=1,
+    help="minimum number of peers to await for first alias",
+)
+@arg(
+    "--mqtt-case",
+    type=case,
+    dest="case",
+    help="case name (broker will determine if you are allowed to access this data)",
+)
+@arg("--mqtt-port", type=port, dest="port", default=443, help="broker connection port")
+@arg("--mqtt-broker", default="localhost", dest="broker", help="broker ip-address")
+@arg("--mqtt-key", type=Path, dest="key", required=True, help="private key file")
+@arg("--mqtt-crt", type=Path, dest="crt", required=True, help="client certificate file")
+@arg("--mqtt-ca", type=Path, dest="ca", required=True, help="certificate authority file")
 @arg("--mqtt-command", dest="command", help="direct command to client(s)")
 @arg("--mqtt-diag", action="store_true", dest="diag", help="show MQTT diagnostic information")
-@arg("--mqtt-username", dest="username", help="Username for connection")
+@arg("--mqtt-username", dest="username", default="mqtt-loader", help="Username for connection")
 @arg("--mqtt-password", action="store_true", dest="password", help="Ask for password before connecting")
 class MQTTLoader(Loader):
     """Load remote targets through a broker."""

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/dissect/target/tools/query.py

@@ -18,7 +18,6 @@ from dissect.target.exceptions import (
     UnsupportedPluginError,
 )
 from dissect.target.helpers import cache, record_modifier
-from dissect.target.loaders.targetd import ProxyLoader
 from dissect.target.plugin import PLUGINS, OSPlugin, Plugin, find_plugin_functions
 from dissect.target.report import ExecutionReport
 from dissect.target.tools.utils import (
@@ -174,8 +173,6 @@ def main():
 
         if targets:
             for plugin_target in Target.open_all(targets, args.children):
-                if isinstance(plugin_target._loader, ProxyLoader):
-                    parser.error("can't list compatible plugins for remote targets.")
                 funcs, _ = find_plugin_functions(plugin_target, args.list, compatibility=True, show_hidden=True)
                 for func in funcs:
                     collected_plugins[func.path] = func.plugin_desc

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/dissect/target/tools/utils.py

@@ -16,7 +16,6 @@ from dissect.target import Target
 from dissect.target.exceptions import UnsupportedPluginError
 from dissect.target.helpers import docs, keychain
 from dissect.target.helpers.docs import get_docstring
-from dissect.target.helpers.targetd import CommandProxy
 from dissect.target.loader import LOADERS_BY_SCHEME
 from dissect.target.plugin import (
     OSPlugin,
@@ -250,9 +249,6 @@ def plugin_function_with_argparser(
 
         plugin_method = plugin_obj.get_all_records
         parser = generate_argparse_for_plugin(plugin_obj)
-    elif isinstance(target_attr, CommandProxy):
-        plugin_method = target_attr.command()
-        parser = generate_argparse_for_bound_method(plugin_method)
     elif callable(target_attr):
         plugin_method = target_attr
         parser = generate_argparse_for_bound_method(target_attr)

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.20.dev5
+Version: 3.20.dev6
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/dissect.target.egg-info/SOURCES.txt

@@ -78,7 +78,6 @@ dissect/target/helpers/record_modifier.py
 dissect/target/helpers/regutil.py
 dissect/target/helpers/shell_application_ids.py
 dissect/target/helpers/shell_folder_ids.py
-dissect/target/helpers/targetd.py
 dissect/target/helpers/utils.py
 dissect/target/helpers/compat/__init__.py
 dissect/target/helpers/compat/path_310.py
@@ -116,7 +115,6 @@ dissect/target/loaders/smb.py
 dissect/target/loaders/tanium.py
 dissect/target/loaders/tar.py
 dissect/target/loaders/target.py
-dissect/target/loaders/targetd.py
 dissect/target/loaders/utm.py
 dissect/target/loaders/vb.py
 dissect/target/loaders/vbox.py

{dissect_target-3.20.dev5 → dissect_target-3.20.dev6}/tests/loaders/test_mqtt.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
-import sys
+import argparse
 import time
 from dataclasses import dataclass
 from struct import pack
 from typing import Iterator
 from unittest.mock import MagicMock, patch
 
+import paho.mqtt.client as mqtt
 import pytest
 
 from dissect.target import Target
+from dissect.target.loaders.mqtt import Broker, MQTTConnection, case
 
 
 class MQTTMock(MagicMock):
@@ -67,24 +69,6 @@ class MockBroker(MagicMock):
         return None
 
 
-@pytest.fixture
-def mock_paho(monkeypatch: pytest.MonkeyPatch) -> Iterator[MagicMock]:
-    with monkeypatch.context() as m:
-        mock_paho = MagicMock()
-        m.setitem(sys.modules, "paho", mock_paho)
-        m.setitem(sys.modules, "paho.mqtt", mock_paho.mqtt)
-        m.setitem(sys.modules, "paho.mqtt.client", mock_paho.mqtt.client)
-
-        yield mock_paho
-
-
-@pytest.fixture
-def mock_client(mock_paho: MagicMock) -> Iterator[MagicMock]:
-    mock_client = MQTTMock()
-    mock_paho.mqtt.client.Client.return_value = mock_client
-    yield mock_client
-
-
 @pytest.fixture
 def mock_broker() -> Iterator[MockBroker]:
     yield MockBroker()
@@ -103,7 +87,7 @@ def mock_broker() -> Iterator[MockBroker]:
 @patch.object(time, "sleep")  # improve speed during test, no need to wait for peers
 def test_remote_loader_stream(
     time: MagicMock,
-    mock_client: MagicMock,
+    monkeypatch: pytest.MonkeyPatch,
     alias: str,
     hosts: list[str],
     disks: list[int],
@@ -112,7 +96,7 @@ def test_remote_loader_stream(
     read: int,
     expected: bytes,
 ) -> None:
-    from dissect.target.loaders.mqtt import Broker
+    monkeypatch.setattr(mqtt, "Client", MQTTMock)
 
     broker = Broker("0.0.0.0", "1884", "key", "crt", "ca", "case1", "user", "pass")
     broker.connect()
@@ -133,8 +117,6 @@ def test_remote_loader_stream(
 
 
 def test_mqtt_loader_prefetch(mock_broker: MockBroker) -> None:
-    from dissect.target.loaders.mqtt import MQTTConnection
-
     connection = MQTTConnection(mock_broker, "")
     connection.prefetch_factor_inc = 10
     assert connection.factor == 1
@@ -148,3 +130,34 @@ def test_mqtt_loader_prefetch(mock_broker: MockBroker) -> None:
     connection.read(1, 1200, 100, 0)
     assert connection.factor == (connection.prefetch_factor_inc * 2) + 1
     assert connection.prev == 1200
+
+
+@pytest.mark.parametrize(
+    "case_name, parse_result",
+    [
+        ("valid_case_name", "valid_case_name"),
+        ("ValidCase123", "ValidCase123"),
+        ("valid_case_123", "valid_case_123"),
+        ("invalid-case", pytest.raises(argparse.ArgumentTypeError)),
+        ("invalid case", pytest.raises(argparse.ArgumentTypeError)),
+        ("invalid.case", pytest.raises(argparse.ArgumentTypeError)),
+        ("invalid@case", pytest.raises(argparse.ArgumentTypeError)),
+        ("", pytest.raises(argparse.ArgumentTypeError)),
+    ],
+    ids=[
+        "valid_case_lower",
+        "valid_case_mixed",
+        "valid_case_with_numbers",
+        "invalid_case_hyphen",
+        "invalid_case_space",
+        "invalid_case_dot",
+        "invalid_case_special_char",
+        "invalid_case_empty",
+    ],
+)
+def test_case(case_name, parse_result: str | pytest.RaisesContext[argparse.ArgumentTypeError]) -> None:
+    if isinstance(parse_result, str):
+        assert case(case_name) == parse_result
+    else:
+        with parse_result:
+            case(case_name)

dissect_target-3.20.dev5/dissect/target/helpers/targetd.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import functools
-from typing import Any, Callable, Optional, Union
-
-from dissect.util.stream import AlignedStream
-
-from dissect.target.exceptions import FatalError
-from dissect.target.loader import Loader
-
-
-class TargetdStream(AlignedStream):
-    def _read(self, offset: int, length: int) -> bytes:
-        return b""
-
-
-# Marker interface to indicate this loader loads targets from remote machines
-class ProxyLoader(Loader):
-    pass
-
-
-class TargetdInvalidStateError(FatalError):
-    pass
-
-
-class CommandProxy:
-    def __init__(self, loader: Loader, func: Callable, namespace: Optional[str] = None):
-        self._loader = loader
-        self._func = func
-        self._namespace = namespace or func
-
-    def __getattr__(self, func: Union[Callable, str]) -> CommandProxy:
-        if func == "func":
-            return self._func.func
-        self._func = func
-        return self
-
-    def command(self) -> Callable:
-        namespace = None if self._func == self._namespace else self._namespace
-        return self._get(namespace, self._func)
-
-    def _get(self, namespace: Optional[str], plugin_func: Callable) -> Callable:
-        if namespace:
-            func = functools.update_wrapper(
-                functools.partial(self._loader.plugin_bridge, plugin_func=self._func, namespace=self._namespace),
-                self._loader.plugin_bridge,
-            )
-        else:
-            func = functools.update_wrapper(
-                functools.partial(self._loader.plugin_bridge, plugin_func=plugin_func), self._loader.plugin_bridge
-            )
-        return func
-
-    def __call__(self, *args, **kwargs) -> Any:
-        return self.command()(*args, **kwargs)
-
-    def __repr__(self) -> str:
-        return str(self._get(None, "get")(**{"property_name": self._func}))

dissect_target-3.20.dev5/dissect/target/loaders/targetd.py

@@ -1,223 +0,0 @@
-from __future__ import annotations
-
-import functools
-import ssl
-import time
-import urllib
-from pathlib import Path
-from platform import os
-from typing import Any, Callable, Optional, Union
-
-from dissect.target.containers.raw import RawContainer
-from dissect.target.exceptions import LoaderError
-
-# to avoid loading issues during automatic loader detection
-from dissect.target.helpers.targetd import (
-    CommandProxy,
-    ProxyLoader,
-    TargetdInvalidStateError,
-    TargetdStream,
-)
-from dissect.target.loader import Loader
-from dissect.target.plugin import Plugin, export
-from dissect.target.target import Target
-
-TARGETD_AVAILABLE = False
-try:
-    from flow import remoting
-    from targetd.clients import Client
-
-    TARGETD_AVAILABLE = True
-except Exception:
-    pass
-
-
-class TargetdLoader(ProxyLoader):
-    """Load remote targets through a broker."""
-
-    instance = None
-
-    def __init__(self, path: Union[Path, str], **kwargs):
-        super().__init__(path)
-        self._plugin_func = None
-        self.client = None
-        self.output = None
-        self.peers = 1
-        self.cacert = None
-        self.adapter = "Flow.Remoting"
-        self.host = "localhost"
-        self.port = 1883
-        self.chunking = True
-        self.local_link = "unix:///tmp/targetd" if os.name == "posix" else "pipe:///tmp/targetd"
-        # @todo Add these options to loader help (when available)
-        self.configurables = [
-            ["cacert", Path, "SSL: cacert file"],
-            ["host", str, "IP-address of targetd broker"],
-            ["port", int, "Port for connecting to targetd broker"],
-            ["local_link", str, "Domain socket or named pipe"],
-            ["adapter", str, "Adapter to use"],
-            ["peers", int, "Minimum number of hosts to wait for before executing query"],
-            ["chunking", int, "Chunk mode"],
-        ]
-        uri = kwargs.get("parsed_path")
-        if uri is None:
-            raise LoaderError("No URI connection details have been passed.")
-        self.uri = uri.path
-        self.options = dict(urllib.parse.parse_qsl(uri.query, keep_blank_values=True))
-
-    def _process_options(self, target: Target) -> None:
-        for configurable_details in self.configurables:
-            configurable, value_type, description = configurable_details
-            configuration = self.options.get(configurable)
-            if not configuration:
-                default_value = getattr(self, configurable)
-                target.log.warning("%s not configured, using: %s=%s", description, configurable, default_value)
-            else:
-                setattr(self, configurable, value_type(configuration))
-
-    @export(output="record", cache=False)
-    def plugin_bridge(self, *args, **kwargs) -> list[Any]:
-        """Command Execution Bridge Plugin for Targetd.
-
-        This is a generic plugin interceptor that becomes active only if using
-        the targetd loader. This plugin acts as a bridge to connect to the Targetd broker
-        and will translate the requested plugin-operation into Targetd-commands using the selected
-        adapter (i.e. Flow.Remoting).
-        """
-
-        if not TARGETD_AVAILABLE:
-            raise ImportError("This loader requires the targetd package to be installed.")
-
-        self.output = None
-        self.has_output = False
-
-        plugin_func = kwargs.pop("plugin_func", None)
-
-        if self.client is None:
-            ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-            ssl_context.check_hostname = False
-            if self.cacert and not self.cacert.exists():
-                raise LoaderError(f"file not found: {self.cacert}")
-            if self.cacert:
-                ssl_context.load_verify_locations(self.cacert)
-            else:
-                ssl_context.load_default_certs(purpose=ssl.Purpose.SERVER_AUTH)
-            self.client = Client(self.host, self.port, ssl_context, [self.uri], self.local_link, "targetd")
-            self.client.module_fullname = "dissect.target.loaders"
-            self.client.module_fromlist = ["command_runner"]
-            self.client.command = plugin_func
-            try:
-                self.client.start(*args, **kwargs)
-            except Exception:
-                # If something happens that prevents targetd from properly closing/resetting the
-                # connection, this exception is thrown during the next connection and the connection
-                # is closed properly after all so that the next time the loader will be able to
-                # use a new connection with a new session.
-                self.client.close()
-                raise TargetdInvalidStateError("Targetd connection is in invalid state, retry.")
-        else:
-            self.client.command = plugin_func
-            self.client.exec_command(*args, **kwargs)
-
-        while not self.has_output:
-            time.sleep(1)
-        return self.output
-
-    def _get_command(self, func: str, namespace: str = None) -> tuple[Loader, functools.partial]:
-        return (self, CommandProxy(self, func, namespace=namespace))
-
-    def each(self, func: Callable, target: Optional[Target] = None) -> Any:
-        """Allows you to attach a scriptlet (function) to each of the remote hosts.
-        The results of the function are accumulated using +=. Exceptions are
-        catched and logged as warnings.
-
-        Usage:
-
-        def my_function(remote_target):
-            ...do something interesting...
-
-        targets = Target.open( targetd://... )
-        targets.each(my_function)
-
-        """
-        result = None
-        if not self.client:
-            target.init()
-        for peer in self.client.peers:
-            target.select(peer)
-            try:
-                if result is None:
-                    result = func(target)
-                else:
-                    result += func(target)
-            except Exception as failure:
-                target.log.warning("Exception while applying function to target: %s: %s", peer, failure)
-        return result
-
-    def _add_plugin(self, plugin: Plugin):
-        plugin.check_compatibe = lambda: True
-
-    def map(self, target: Target) -> None:
-        if TargetdLoader.instance:
-            raise Exception("You can only initiated 1 targetd control connection per session.")
-        self._process_options(target)
-        target.disks.add(RawContainer(TargetdStream()))
-        target.get_function = self._get_command
-        target.add_plugin = self._add_plugin
-        target.each = functools.update_wrapper(functools.partial(self.each, target=target), self.each)
-        TargetdLoader.instance = self
-
-    @staticmethod
-    def detect(path: Path) -> bool:
-        # You can only activate this loader by URI-scheme "targetd://"
-        return False
-
-    def __del__(self) -> None:
-        if self.client:
-            self.client.close()
-
-
-if TARGETD_AVAILABLE:
-    # Loader has to provide the control script for targetd in this case
-    def command_runner(link: str, targetd: Client, *args, **kwargs) -> None:
-        caller = TargetdLoader.instance
-        if not targetd.rpcs:
-            targetd.easy_connect_remoting(remoting, link, caller.peers)
-
-        obj = targetd.rpcs
-        if namespace := kwargs.get("namespace", None):
-            obj = getattr(obj, namespace)
-
-        caller.has_output = True
-        if targetd.command == "init":
-            caller.output = True
-            return
-
-        if targetd.command == "select":
-            targetd.rpcs.select(*args)
-            caller.output = True
-            return
-
-        if targetd.command == "deselect":
-            targetd.rpcs.deselect()
-            caller.output = True
-            return
-
-        func = getattr(obj, targetd.command)
-
-        result = func(*args, **kwargs)
-        if result is not None:
-            if targetd.command == "get":
-                result = list(result)[0]
-            elif caller.chunking:
-                data = []
-                gen = func()
-                targetd.reset()
-                while True:
-                    try:
-                        data.append(next(gen))
-                    except Exception:
-                        break
-                result = data
-            caller.output = result
-        targetd.reset()