dissect.target 3.19.dev52__tar.gz → 3.19.dev54__tar.gz

{dissect_target-3.19.dev52/dissect.target.egg-info → dissect_target-3.19.dev54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev52
+Version: 3.19.dev54
 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.19.dev52 → dissect_target-3.19.dev54}/dissect/target/plugins/filesystem/ntfs/mft.py

@@ -138,12 +138,18 @@ class MftPlugin(Plugin):
             FilesystemFilenameCompactRecord,
         ]
     )
-    @arg("--compact", action="store_true", help="compacts the MFT entry timestamps into a single record")
+    @arg(
+        "--compact",
+        group="fmt",
+        action="store_true",
+        help="compacts the MFT entry timestamps into a single record",
+    )
     @arg("--fs", type=int, default=None, help="optional filesystem index, zero indexed")
     @arg("--start", type=int, default=0, help="the first MFT segment number")
     @arg("--end", type=int, default=-1, help="the last MFT segment number")
     @arg(
         "--macb",
+        group="fmt",
         action="store_true",
         help="compacts the MFT entry timestamps into aggregated records with MACB bitfield",
     )
@@ -171,9 +177,7 @@ class MftPlugin(Plugin):
 
         aggr = noaggr
 
-        if compact and macb:
-            raise ValueError("--macb and --compact are mutually exclusive")
-        elif compact:
+        if compact:
             record_formatter = compacted_formatter
         elif macb:
             aggr = macb_aggr

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/dissect/target/plugins/os/unix/bsd/freebsd/_os.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from dissect.target.filesystem import Filesystem
 from dissect.target.plugin import export
 from dissect.target.plugins.os.unix.bsd._os import BsdPlugin
@@ -14,13 +12,13 @@ class FreeBsdPlugin(BsdPlugin):
         self._os_release = self._parse_os_release("/bin/freebsd-version*")
 
     @classmethod
-    def detect(cls, target: Target) -> Optional[Filesystem]:
+    def detect(cls, target: Target) -> Filesystem | None:
         for fs in target.filesystems:
-            if fs.exists("/net") or fs.exists("/.sujournal"):
+            if fs.exists("/net") and (fs.exists("/.sujournal") or fs.exists("/entropy")):
                 return fs
 
         return None
 
     @export(property=True)
-    def version(self) -> Optional[str]:
+    def version(self) -> str | None:
         return self._os_release.get("USERLAND_VERSION")

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/dissect/target/plugins/os/unix/linux/_os.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import logging
-from typing import Optional
 
 from dissect.target.filesystem import Filesystem
 from dissect.target.helpers.network_managers import (
@@ -8,6 +9,8 @@ from dissect.target.helpers.network_managers import (
 )
 from dissect.target.plugin import OperatingSystem, export
 from dissect.target.plugins.os.unix._os import UnixPlugin
+from dissect.target.plugins.os.unix.bsd.osx._os import MacPlugin
+from dissect.target.plugins.os.windows._os import WindowsPlugin
 from dissect.target.target import Target
 
 log = logging.getLogger(__name__)
@@ -20,17 +23,13 @@ class LinuxPlugin(UnixPlugin, LinuxNetworkManager):
         self.network_manager.discover()
 
     @classmethod
-    def detect(cls, target: Target) -> Optional[Filesystem]:
+    def detect(cls, target: Target) -> Filesystem | None:
         for fs in target.filesystems:
             if (
-                fs.exists("/var")
-                and fs.exists("/etc")
-                and fs.exists("/opt")
-                or (fs.exists("/sys") or fs.exists("/proc"))
-                and not fs.exists("/Library")
-            ):
+                (fs.exists("/var") and fs.exists("/etc") and fs.exists("/opt"))
+                or (fs.exists("/sys/module") or fs.exists("/proc/sys"))
+            ) and not (MacPlugin.detect(target) or WindowsPlugin.detect(target)):
                 return fs
-        return None
 
     @export(property=True)
     def ips(self) -> list[str]:
@@ -68,7 +67,7 @@ class LinuxPlugin(UnixPlugin, LinuxNetworkManager):
         return self.network_manager.get_config_value("netmask")
 
     @export(property=True)
-    def version(self) -> str:
+    def version(self) -> str | None:
         distrib_description = self._os_release.get("DISTRIB_DESCRIPTION", "")
         name = self._os_release.get("NAME", "") or self._os_release.get("DISTRIB_ID", "")
         version = (
@@ -78,10 +77,9 @@ class LinuxPlugin(UnixPlugin, LinuxNetworkManager):
         )
 
         if len(f"{name} {version}") > len(distrib_description):
-            return f"{name} {version}"
+            distrib_description = f"{name} {version}"
 
-        else:
-            return distrib_description
+        return distrib_description or None
 
     @export(property=True)
     def os(self) -> str:

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/dissect/target/tools/utils.py

@@ -95,12 +95,24 @@ def generate_argparse_for_unbound_method(
     parser = argparse.ArgumentParser(description=desc, formatter_class=help_formatter, conflict_handler="resolve")
 
     fargs = getattr(method, "__args__", [])
+    groups = {}
+    default_group_options = {"required": False}
     for args, kwargs in fargs:
-        parser.add_argument(*args, **kwargs)
+        if "group" in kwargs:
+            group_name = kwargs.pop("group")
+            options = kwargs.pop("group_options") if "group_options" in kwargs else default_group_options
+            if group_name not in groups:
+                group = parser.add_mutually_exclusive_group(**options)
+                groups[group_name] = group
+            else:
+                group = groups[group_name]
+
+            group.add_argument(*args, **kwargs)
+        else:
+            parser.add_argument(*args, **kwargs)
 
     usage = parser.format_usage()
     offset = usage.find(parser.prog) + len(parser.prog)
-
     func_name = method.__name__
     usage_tmpl = usage_tmpl or "{prog} {usage}"
     parser.usage = usage_tmpl.format(prog=parser.prog, name=func_name, usage=usage[offset:])

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev52
+Version: 3.19.dev54
 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.19.dev52 → dissect_target-3.19.dev54}/dissect.target.egg-info/SOURCES.txt

@@ -526,6 +526,7 @@ tests/plugins/os/unix/bsd/osx/test_user.py
 tests/plugins/os/unix/esxi/__init__.py
 tests/plugins/os/unix/esxi/test__os.py
 tests/plugins/os/unix/linux/__init__.py
+tests/plugins/os/unix/linux/test__os.py
 tests/plugins/os/unix/linux/test_cmdline.py
 tests/plugins/os/unix/linux/test_environ.py
 tests/plugins/os/unix/linux/test_iptables.py

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/tests/conftest.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import pathlib
 import tempfile
 import textwrap
 from io import BytesIO
-from typing import Callable, Iterator, Optional
+from typing import Callable, Iterator
 
 import pytest
 
@@ -50,7 +52,7 @@ def make_mock_target(tmp_path: pathlib.Path) -> Iterator[Target]:
 def make_os_target(
     tmp_path: pathlib.Path,
     os_plugin: type[OSPlugin],
-    root_fs: Optional[Filesystem] = None,
+    root_fs: Filesystem | None = None,
     apply_target: bool = True,
 ) -> Target:
     mock_target = next(make_mock_target(tmp_path))
@@ -126,6 +128,12 @@ def fs_suse() -> Iterator[VirtualFilesystem]:
     yield fs
 
 
+@pytest.fixture
+def fs_linux_sys(fs_linux: VirtualFilesystem) -> Iterator[VirtualFilesystem]:
+    fs_linux.makedirs("sys")
+    yield fs_linux
+
+
 @pytest.fixture
 def fs_linux_proc(fs_linux: VirtualFilesystem) -> Iterator[VirtualFilesystem]:
     fs = fs_linux

dissect_target-3.19.dev54/tests/plugins/os/unix/linux/test__os.py

@@ -0,0 +1,49 @@
+import pathlib
+from typing import Iterator
+
+import pytest
+
+from dissect.target import Target
+from dissect.target.filesystem import VirtualFilesystem
+from dissect.target.plugins.os.unix.linux._os import LinuxPlugin
+from tests.conftest import make_os_target
+
+
+@pytest.fixture
+def target_linux_proc_sys(tmp_path: pathlib.Path) -> Iterator[Target]:
+    root_fs = VirtualFilesystem()
+    root_fs.makedirs("/proc/sys")
+    root_fs.makedirs("/sys/module")
+    target_linux_proc_sys = make_os_target(tmp_path, LinuxPlugin, root_fs)
+
+    yield target_linux_proc_sys
+
+
+@pytest.fixture
+def target_linux_windows_folder(tmp_path: pathlib.Path) -> Iterator[Target]:
+    root_fs = VirtualFilesystem()
+    root_fs.makedirs("/windows")
+    root_fs.makedirs("/var")
+    root_fs.makedirs("/etc")
+    root_fs.makedirs("/opt")
+
+    target_linux_proc_sys = make_os_target(tmp_path, LinuxPlugin, root_fs)
+
+    yield target_linux_proc_sys
+
+
+def test_linux_os(target_linux: Target) -> None:
+    target_linux.add_plugin(LinuxPlugin)
+
+    assert target_linux.os == "linux"
+
+
+def test_linux_os_windows_folder(target_linux_windows_folder: Target) -> None:
+    target_linux_windows_folder.add_plugin(LinuxPlugin)
+    assert target_linux_windows_folder._os_plugin.detect(target_linux_windows_folder) is not None
+    assert target_linux_windows_folder.os == "linux"
+
+
+def test_linux_os_proc_sys(target_linux_proc_sys: Target) -> None:
+    assert target_linux_proc_sys._os_plugin.detect(target_linux_proc_sys) is not None
+    assert target_linux_proc_sys.os == "linux"

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/tests/plugins/os/windows/test__os.py

@@ -1,8 +1,12 @@
-from typing import Any, Optional
+from __future__ import annotations
+
+from typing import Any, Iterator
 
 import pytest
 
+from dissect.target.filesystem import Filesystem
 from dissect.target.helpers.regutil import VirtualKey, VirtualValue
+from dissect.target.plugins.os.unix.linux._os import LinuxPlugin
 from dissect.target.plugins.os.windows._os import WindowsPlugin
 from dissect.target.plugins.os.windows.registry import RegistryPlugin
 from dissect.target.target import Target
@@ -31,7 +35,13 @@ def win_plugin(version_target: Target):
     return WindowsPlugin(version_target)
 
 
-def map_version_value(target: Target, name: Optional[str], value: Any):
+@pytest.fixture
+def target_win_linux_folders(target_win: Filesystem, fs_linux_sys: Filesystem) -> Iterator[Target]:
+    target_win.fs.mount("/", fs_linux_sys)
+    yield target_win
+
+
+def map_version_value(target: Target, name: str | None, value: Any):
     if name is not None:
         hive = target.registry._root
         hive.map_value(CURRENT_VERSION_KEY, name, VirtualValue(hive, name, value))
@@ -54,7 +64,7 @@ def assert_value(result: Any, value: Any):
 def test_windowsplugin__legacy_curre_ntversion(
     version_target: Target,
     win_plugin: WindowsPlugin,
-    name: Optional[str],
+    name: str | None,
     value: Any,
 ):
     map_version_value(version_target, name, value)
@@ -73,7 +83,7 @@ def test_windowsplugin__legacy_curre_ntversion(
 def test_windowsplugin__major_version(
     version_target: Target,
     win_plugin: WindowsPlugin,
-    name: Optional[str],
+    name: str | None,
     value: Any,
 ):
     map_version_value(version_target, name, value)
@@ -92,7 +102,7 @@ def test_windowsplugin__major_version(
 def test_windowsplugin__minor_version(
     version_target: Target,
     win_plugin: WindowsPlugin,
-    name: Optional[str],
+    name: str | None,
     value: Any,
 ):
     map_version_value(version_target, name, value)
@@ -129,7 +139,7 @@ def test_windowsplugin__nt_version(
     version_target: Target,
     win_plugin: WindowsPlugin,
     keys: list[tuple[str, Any]],
-    value: Optional[str],
+    value: str | None,
 ):
     for key_name, key_value in keys:
         map_version_value(version_target, key_name, key_value)
@@ -228,10 +238,18 @@ def test_windowsplugin_version(
     version_target: Target,
     win_plugin: WindowsPlugin,
     keys: list[tuple[str, Any]],
-    value: Optional[str],
+    value: str | None,
 ):
     for key_name, key_value in keys:
         map_version_value(version_target, key_name, key_value)
     result = win_plugin.version
 
     assert_value(result, value)
+
+
+def test_windows_os_detection_with_linux_folders(target_win_linux_folders: Target) -> None:
+    fs_linux = LinuxPlugin.detect(target_win_linux_folders)
+    fs_windows = WindowsPlugin.detect(target_win_linux_folders)
+
+    assert fs_linux is None
+    assert fs_windows is not None

{dissect_target-3.19.dev52 → dissect_target-3.19.dev54}/tests/tools/test_utils.py

@@ -8,6 +8,7 @@ from dissect.target.exceptions import UnsupportedPluginError
 from dissect.target.plugin import arg, find_plugin_functions
 from dissect.target.tools.utils import (
     args_to_uri,
+    generate_argparse_for_unbound_method,
     get_target_attribute,
     persist_execution_report,
 )
@@ -77,3 +78,17 @@ def test_plugin_name_confusion_regression(target_unix_users, pattern, expected_f
         get_target_attribute(target_unix_users, plugins[0])
 
     assert expected_function in str(exc_info.value)
+
+
+def test_plugin_mutual_exclusive_arguments():
+    fargs = [
+        (("--aa",), {"group": "aa"}),
+        (("--bb",), {"group": "aa"}),
+        (("--cc",), {"group": "bb"}),
+        (("--dd",), {"group": "bb"}),
+    ]
+    method = test_plugin_mutual_exclusive_arguments
+    setattr(method, "__args__", fargs)
+    with patch("inspect.isfunction", return_value=True):
+        parser = generate_argparse_for_unbound_method(method)
+    assert len(parser._mutually_exclusive_groups) == 2