dissect.target 3.22.dev60__tar.gz → 3.22.dev61__tar.gz

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev60
+Version: 3.22.dev61
 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.22.dev60 → dissect_target-3.22.dev61}/dissect/target/filesystems/config.py

@@ -122,7 +122,8 @@ class ConfigurationFilesystem(VirtualFilesystem):
         entry = file_entry
         config_parser = None
         try:
-            config_parser = parse(entry, *args, **kwargs)
+            target_path = entry.fs.path(entry.path)
+            config_parser = parse(target_path, *args, **kwargs)
         except ConfigurationParsingError as e:
             # If a parsing error gets created, it should return the `entry`
             log.debug("Error when parsing %s with message '%s'", entry.path, e)

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/dissect/target/helpers/configutil.py

@@ -9,8 +9,6 @@ from collections import deque
 from collections.abc import ItemsView, Iterable, Iterator, KeysView
 from configparser import ConfigParser, MissingSectionHeaderError
 from dataclasses import dataclass
-from fnmatch import fnmatch
-from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -22,15 +20,14 @@ from typing import (
 from defusedxml import ElementTree
 
 from dissect.target.exceptions import ConfigurationParsingError, FileNotFoundError
-from dissect.target.helpers.fsutil import TargetPath
+from dissect.target.helpers.utils import to_list
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from types import TracebackType
 
     from typing_extensions import Self
 
-    from dissect.target.filesystem import FilesystemEntry
-
 try:
     from ruamel.yaml import YAML
 
@@ -54,9 +51,8 @@ log = logging.getLogger(__name__)
 
 
 def _update_dictionary(current: dict[str, Any], key: str, value: Any) -> None:
-    if prev_value := current.get(key):
-        if isinstance(prev_value, dict):
-            # We can assume the value would be a dict too here.
+    if (prev_value := current.get(key)) is not None:  #  "" is a value
+        if isinstance(prev_value, dict) and isinstance(value, dict):
             prev_value.update(value)
             return
 
@@ -180,6 +176,44 @@ class ConfigurationParser:
         if not isinstance(self.parsed_data, dict):
             self.parsed_data = self._collapse_dict(self.parsed_data, False)
 
+    def merge(self, other: ConfigurationParser) -> ConfigurationParser:
+        """Merge the contents of another parser into this one.
+        On conflict, the values of the other parser will be used.
+
+        Args:
+            other: The other parser to merge.
+
+        Returns:
+            The merged parser.
+        """
+
+        self._merge(self.parsed_data, other.parsed_data)
+        return self
+
+    def _merge(self, dict1: dict, dict2: dict) -> dict:
+        for key, value2 in dict2.items():
+            value1 = dict1.get(key)
+            if value1 is None:
+                # Result does not have key yet, add it
+                dict1[key] = value2
+                continue
+
+            collapse = self.collapse_all or self._collapse_check(key)
+
+            if collapse:
+                if isinstance(value1, dict) and isinstance(value2, dict):
+                    self._merge(value1, value2)  # There should only be one, merge both
+                else:
+                    dict1[key] = value2
+            else:
+                combined = to_list(value1) + to_list(value2)
+                # An empty string clears the list of values for the current key
+                # Possibly turn this into an option if other parsers require different behavior
+                combined = combined[combined.index("") + 1 :] if "" in combined else combined
+                dict1[key] = combined
+
+        return dict1
+
     def keys(self) -> KeysView:
         return self.parsed_data.keys()
 
@@ -568,13 +602,26 @@ class ScopeManager:
 
     def push(self, name: str, keep_prev: bool = False) -> Literal[True]:
         """Push a new key to the :attr:`_current` dictionary and return that we did."""
-        child = self._current.get(name, {})
-
+        child = self._current.get(name)
+        new_child = {}
         parent = self._current
-        self._parents[id(child)] = parent
-        parent[name] = child
+        if isinstance(child, dict):
+            # A second scope with the same name, turn the existing one into a list and append a new one
+            parent[name] = [child, new_child]
+            child = parent[name]
+        elif isinstance(child, list):
+            # Multiple scopes with the same name, append a new one to the list
+            child.append(new_child)
+        elif isinstance(child, str):
+            # Child is not a scope but a scalar value, do nothing
+            pass
+        else:
+            # Create a new scope
+            parent[name] = new_child
+
+        self._parents[id(new_child)] = parent
         self._set_prev(keep_prev)
-        self._current = child
+        self._current = new_child
         return True
 
     def pop(self, keep_prev: bool = False) -> bool:
@@ -888,7 +935,7 @@ KNOWN_FILES: dict[str, type[ConfigurationParser]] = {
 }
 
 
-def parse(path: FilesystemEntry | TargetPath | Path, hint: str | None = None, *args, **kwargs) -> ConfigurationParser:
+def parse(path: Path, hint: str | None = None, *args, **kwargs) -> ConfigurationParser:
     """Parses the content of an ``path`` or ``entry`` to a dictionary.
 
     Args:
@@ -903,42 +950,55 @@ def parse(path: FilesystemEntry | TargetPath | Path, hint: str | None = None, *a
         FileNotFoundError: If the ``path`` is not a file.
     """
 
-    entry = path
-    if isinstance(path, TargetPath):
-        entry = path.get()
-
-    if not isinstance(entry, Path) and not entry.is_file(follow_symlinks=True):
+    if not path.is_file():
         raise FileNotFoundError(f"Could not parse {path} as a dictionary.")
 
     options = ParserOptions(*args, **kwargs)
 
-    return parse_config(entry, hint, options)
+    return parse_config(path, hint, options)
 
 
 def parse_config(
-    entry: FilesystemEntry | Path,
+    entry: Path,
     hint: str | None = None,
     options: ParserOptions | None = None,
 ) -> ConfigurationParser:
     parser_type = _select_parser(entry, hint)
 
     parser = parser_type.create_parser(options)
-    with entry.open("rb") if isinstance(entry, Path) else entry.open() as fh:
+    with entry.open("rb") as fh:
         open_file = io.TextIOWrapper(fh, encoding="utf-8") if not isinstance(parser, Bin) else io.BytesIO(fh.read())
         parser.read_file(open_file)
 
+    if isinstance(parser, SystemD):
+        return _parse_drop_files(entry, options, parser)
+
     return parser
 
 
-def _select_parser(entry: FilesystemEntry, hint: str | None = None) -> ParserConfig:
+def _parse_drop_files(path: Path, options: ParserOptions, main_parser: ConfigurationParser) -> ConfigurationParser:
+    if not (drop_folder := path.with_name(path.name + ".d")).exists():
+        return main_parser
+
+    for drop_file in sorted(drop_folder.glob("*.conf")):
+        if not drop_file.is_file():
+            continue
+
+        drop_file_parser = ParserConfig(SystemD).create_parser(options)
+        with drop_file.open("r") as fh:
+            drop_file_parser.read_file(fh)
+            main_parser.merge(drop_file_parser)
+
+    return main_parser
+
+
+def _select_parser(path: Path, hint: str | None = None) -> ParserConfig:
     if hint and (parser_type := CONFIG_MAP.get(hint)):
         return parser_type
 
     for match, value in MATCH_MAP.items():
-        if fnmatch(entry.path, f"{match}"):
+        if path.match(match):
             return value
 
-    extension = entry.path.rsplit(".", 1)[-1]
-
-    extention_parser = CONFIG_MAP.get(extension, ParserConfig(Default))
-    return KNOWN_FILES.get(entry.name, extention_parser)
+    extention_parser = CONFIG_MAP.get(path.suffix.lstrip("."), ParserConfig(Default))
+    return KNOWN_FILES.get(path.name, extention_parser)

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/dissect/target/plugins/os/unix/linux/network.py

@@ -4,6 +4,7 @@ import re
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from ipaddress import ip_address, ip_interface
+from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, NamedTuple
 
 from dissect.target.helpers import configutil
@@ -199,6 +200,8 @@ class SystemdNetworkConfigParser(LinuxNetworkConfigParser):
     Documentation: https://www.freedesktop.org/software/systemd/man/latest/systemd.network.html
     """
 
+    collapsable_items: tuple[str, ...] = ("Match", "Network", "Link", "MACAddress", "Name", "Type")
+
     config_paths: tuple[str, ...] = (
         "/etc/systemd/network/",
         "/run/systemd/network/",
@@ -245,7 +248,7 @@ class SystemdNetworkConfigParser(LinuxNetworkConfigParser):
         """Parse network configurations from systemd network configuration files."""
         for config_file in self._config_files(self.config_paths, "*.network"):
             try:
-                config = configutil.parse(config_file, hint="systemd")
+                config = configutil.parse(config_file, hint="systemd", collapse=self.collapsable_items)
 
                 match_section: dict[str, str] = config.get("Match", {})
                 network_section: dict[str, str] = config.get("Network", {})
@@ -276,10 +279,9 @@ class SystemdNetworkConfigParser(LinuxNetworkConfigParser):
                     if ids := virtual_networks.get(vlan_name):
                         vlan_ids.update(ids)
 
-                # There are possibly multiple route sections, but they are collapsed into one by the parser.
-                route_section: dict[str, Any] = config.get("Route", {})
-                gateway_values = to_list(route_section.get("Gateway", []))
-                gateways.update(filter(None, map(self._parse_gateway, gateway_values)))
+                route_sections: list[dict[str, Any]] = config.get("Route", [])
+                gateway_values = (to_list(route_section.get("Gateway", [])) for route_section in route_sections)
+                gateways.update(filter(None, map(self._parse_gateway, chain.from_iterable(gateway_values))))
 
                 dhcp_ipv4, dhcp_ipv6 = self._parse_dhcp(network_section.get("DHCP"))
 

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/dissect.target.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev60
+Version: 3.22.dev61
 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.22.dev60 → dissect_target-3.22.dev61}/tests/filesystems/test_config.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
-from io import BytesIO
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-from unittest.mock import Mock
 
 import pytest
 
@@ -11,7 +9,6 @@ from dissect.target.filesystems.config import (
     ConfigurationEntry,
     ConfigurationFilesystem,
 )
-from dissect.target.helpers.configutil import parse_config
 from tests._utils import absolute_path
 
 if TYPE_CHECKING:
@@ -167,40 +164,6 @@ def test_unix_registry(target_unix: Target, etc_directory: VirtualFilesystem) ->
     assert isinstance(config_fs.get("/new/path/config"), ConfigurationEntry)
 
 
-def test_config_entry() -> None:
-    class MockableRead(Mock):
-        def __enter__(self):
-            return self.binary_data
-
-        def __exit__(self, *args):
-            return
-
-    mocked_open = MockableRead(binary_data=BytesIO(b"default=test\n[Unit]\nhelp=me\n"))
-    mocked_entry = Mock()
-    mocked_entry.open.return_value = mocked_open
-    mocked_entry.path = "config.ini"
-
-    parser_items = parse_config(mocked_entry)
-
-    entry = ConfigurationEntry(
-        Mock(),
-        "config.ini",
-        entry=mocked_entry,
-        parser_items=parser_items,
-    )
-    assert entry.is_dir()
-
-    assert list(entry.iterdir()) == ["DEFAULT", "Unit"]
-
-    default_section = entry.get("DEFAULT")
-    assert default_section.is_dir()
-    assert list(default_section.iterdir()) == ["default"]
-    assert default_section.open().read() == b"default\n    test\n"
-
-    default_key_values = default_section.get("default")
-    assert default_key_values.open().read() == b"test\n"
-
-
 def test_parse_functions(target_unix: Target, etc_directory: VirtualFilesystem) -> None:
     config_fs = ConfigurationFilesystem(target_unix, "/etc")
     entry: ConfigurationEntry = config_fs.get("/new/path/config", collapse=True, separator=(r"\s",))

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/tests/helpers/test_configutil.py

@@ -104,6 +104,17 @@ def test_custom_comments(comment_string: str, comment_prefixes: tuple[str, ...])
             """,
             {"key value1": ["value2", "value3"]},
         ),
+        (
+            """
+            key value1
+              key2 value2a
+              key3 value3a
+            key value1
+              key2 value2b
+              key3 value3b
+            """,
+            {"key value1": [{"key2": "value2a", "key3": "value3a"}, {"key2": "value2b", "key3": "value3b"}]},
+        ),
         (
             """
             key value

{dissect_target-3.22.dev60 → dissect_target-3.22.dev61}/tests/plugins/os/unix/linux/test_network.py

@@ -63,7 +63,6 @@ def test_networkmanager_parser(target_linux: Target, fs_linux: VirtualFilesystem
 
 def test_systemd_network_parser(target_linux: Target, fs_linux: VirtualFilesystem) -> None:
     fixture_dir = "tests/_data/plugins/os/unix/linux/systemd.network/"
-    fs_linux.makedirs("/etc/systemd/network")
 
     fs_linux.map_file(
         "/etc/systemd/network/20-wired-static.network", posixpath.join(fixture_dir, "20-wired-static.network")
@@ -148,6 +147,49 @@ def test_systemd_network_parser(target_linux: Target, fs_linux: VirtualFilesyste
     assert wireless_ipv6.dhcp_ipv6
 
 
+def test_systemd_network_drop(target_linux: Target, fs_linux: VirtualFilesystem) -> None:
+    fixture_dir = "tests/_data/plugins/os/unix/linux/systemd.network/"
+
+    fs_linux.map_file(
+        "/etc/systemd/network/30-wired-static-complex.network",
+        posixpath.join(fixture_dir, "30-wired-static-complex.network"),
+    )
+    fs_linux.map_file(
+        "/etc/systemd/network/30-wired-static-complex.network.d/10-override.conf",
+        posixpath.join(fixture_dir, "30-wired-static-complex.network.d/10-override.conf"),
+    )
+    fs_linux.map_file(
+        "/etc/systemd/network/30-wired-static-complex.network.d/20-override.conf",
+        posixpath.join(fixture_dir, "30-wired-static-complex.network.d/20-override.conf"),
+    )
+
+    systemd_network_config_parser = SystemdNetworkConfigParser(target_linux)
+    interfaces = list(systemd_network_config_parser.interfaces())
+
+    assert len(interfaces) == 1
+    [wired_static_complex] = interfaces
+
+    assert wired_static_complex.name == "wlp2s0"
+    assert wired_static_complex.type == "wifi"
+    assert wired_static_complex.enabled is None
+    assert Counter(wired_static_complex.cidr) == Counter([ip_interface("10.1.10.11/16")])
+    assert Counter(wired_static_complex.gateway) == Counter(
+        [ip_address("10.1.6.3"), ip_address("10.1.10.2"), ip_address("10.1.9.3"), ip_address("10.1.10.4")]
+    )
+    assert Counter(wired_static_complex.dns) == Counter(
+        [ip_address("10.1.10.1"), ip_address("10.1.10.2"), ip_address("1111:2222::3333")]
+    )
+    assert Counter(wired_static_complex.mac) == Counter(
+        ["aa::bb::cc::dd::ee::ff", "ff::ee::dd::cc::bb::aa", "cc::ff::bb::aa::dd", "bb::aa::dd::cc::ff"]
+    )
+    assert wired_static_complex.source == "/etc/systemd/network/30-wired-static-complex.network"
+    assert wired_static_complex.dhcp_ipv4
+    assert not wired_static_complex.dhcp_ipv6
+    assert wired_static_complex.last_connected is None
+    assert wired_static_complex.vlan == []
+    assert wired_static_complex.configurator == "systemd-networkd"
+
+
 def test_linux_network_plugin_interfaces(target_linux: Target) -> None:
     """Assert that the LinuxNetworkPlugin aggregates from all Config Parsers."""