dissect.target 3.22.dev7__tar.gz → 3.22.dev9__tar.gz

{dissect_target-3.22.dev7/dissect.target.egg-info → dissect_target-3.22.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev7
+Version: 3.22.dev9
 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.dev7 → dissect_target-3.22.dev9}/dissect/target/helpers/record.py

@@ -145,13 +145,12 @@ EmptyRecord = RecordDescriptor(
 
 COMMON_INTERFACE_ELEMENTS = [
     ("string", "name"),
-    ("string[]", "mac"),
     ("string", "type"),
     ("boolean", "enabled"),
-    ("net.ipaddress[]", "dns"),
-    ("net.ipaddress[]", "ip"),
+    ("net.ipinterface[]", "cidr"),
     ("net.ipaddress[]", "gateway"),
-    ("net.ipnetwork[]", "network"),
+    ("net.ipaddress[]", "dns"),
+    ("string[]", "mac"),
     ("string", "source"),
 ]
 
@@ -176,7 +175,6 @@ WindowsInterfaceRecord = TargetRecordDescriptor(
         ("stringlist", "search_domain"),
         ("datetime", "first_connected"),
         ("datetime", "last_connected"),
-        ("net.ipaddress[]", "subnetmask"),
         ("boolean", "dhcp"),
         ("varint", "vlan"),
     ],

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9}/dissect/target/plugins/os/default/network.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Iterator, Union, get_args
+from operator import attrgetter
+from typing import TYPE_CHECKING, Any, Callable, Union, get_args
 
 from flow.record.fieldtypes.net import IPAddress, IPNetwork
-from flow.record.fieldtypes.net.ipv4 import Address, addr_long, addr_str, mask_to_bits
 
 from dissect.target.helpers.record import (
     MacInterfaceRecord,
@@ -11,8 +11,11 @@ from dissect.target.helpers.record import (
     WindowsInterfaceRecord,
 )
 from dissect.target.plugin import Plugin, export, internal
-from dissect.target.target import Target
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.target import Target
 InterfaceRecord = Union[UnixInterfaceRecord, WindowsInterfaceRecord, MacInterfaceRecord]
 
 
@@ -31,15 +34,15 @@ class NetworkPlugin(Plugin):
     def _interfaces(self) -> Iterator[InterfaceRecord]:
         yield from ()
 
-    def _get_record_type(self, field_name: str) -> Iterator[Any]:
+    def _get_record_type(self, field_name: str, func: Callable[[Any], Any] | None = None) -> Iterator[Any]:
         for record in self.interfaces():
             if (output := getattr(record, field_name, None)) is None:
                 continue
 
-            if isinstance(output, list):
-                yield from output
-            else:
-                yield output
+            if not isinstance(output, list):
+                output = [output]
+
+            yield from (map(func, output) if func else output)
 
     @export(record=get_args(InterfaceRecord))
     def interfaces(self) -> Iterator[InterfaceRecord]:
@@ -53,7 +56,7 @@ class NetworkPlugin(Plugin):
     @export
     def ips(self) -> list[IPAddress]:
         """Return IP addresses as list of :class:`IPAddress`."""
-        return list(set(self._get_record_type("ip")))
+        return list(set(self._get_record_type("cidr", attrgetter("ip"))))
 
     @export
     def gateways(self) -> list[IPAddress]:
@@ -72,26 +75,22 @@ class NetworkPlugin(Plugin):
 
     @internal
     def with_ip(self, ip_addr: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with the given IP address."""
         for interface in self.interfaces():
-            if ip_addr in interface.ip:
+            if any(iface.ip == ip_addr for iface in interface.cidr):
                 yield interface
 
     @internal
     def with_mac(self, mac: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with the given full or partial MAC address."""
         for interface in self.interfaces():
             if mac in interface.mac:
                 yield interface
 
     @internal
     def in_cidr(self, cidr: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with IP addresses in the given CIDR range."""
         cidr = IPNetwork(cidr)
         for interface in self.interfaces():
-            if any(ip_addr in cidr for ip_addr in interface.ip):
+            if any(iface.ip in cidr for iface in interface.cidr):
                 yield interface
-
-    def calculate_network(self, ips: int | Address, subnets: int | Address) -> Iterator[str]:
-        for ip, subnet_mask in zip(ips, subnets):
-            subnet_mask_int = addr_long(subnet_mask)
-            cidr = mask_to_bits(subnet_mask_int)
-            network_address = addr_str(addr_long(ip) & subnet_mask_int)
-            yield f"{network_address}/{cidr}"

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9}/dissect/target/plugins/os/unix/bsd/osx/network.py

@@ -2,11 +2,16 @@ from __future__ import annotations
 
 import plistlib
 from functools import cache, lru_cache
-from typing import Iterator
+from typing import TYPE_CHECKING
 
+from dissect.target.exceptions import FileNotFoundError
 from dissect.target.helpers.record import MacInterfaceRecord
 from dissect.target.plugins.os.default.network import NetworkPlugin
-from dissect.target.target import Target
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.target import Target
 
 
 class MacNetworkPlugin(NetworkPlugin):
@@ -26,6 +31,8 @@ class MacNetworkPlugin(NetworkPlugin):
         if (preferences := self.target.fs.path("/Library/Preferences/SystemConfiguration/preferences.plist")).exists():
             return plistlib.load(preferences.open())
 
+        raise FileNotFoundError("Couldn't find preferences file")
+
     def _interfaces(self) -> Iterator[MacInterfaceRecord]:
         plistnetwork = self._plistnetwork()
         current_set = plistnetwork.get("CurrentSet")
@@ -46,45 +53,46 @@ class MacNetworkPlugin(NetworkPlugin):
         for _id, interface in network.items():
             dns = set()
             gateways = set()
-            ips = set()
             device = interface.get("Interface", {})
             name = device.get("DeviceName")
             _type = device.get("Type")
             vlan = vlan_lookup.get(name)
             dhcp = False
-            subnetmask = []
-            network = []
+            ifaces = set()
             interface_service_order = service_order.index(_id) if _id in service_order else None
             try:
                 for addr in interface.get("DNS", {}).get("ServerAddresses", {}):
                     dns.add(addr)
+
                 for addresses in [interface.get("IPv4", {}), interface.get("IPv6", {})]:
-                    subnetmask += filter(lambda mask: mask != "", addresses.get("SubnetMasks", []))
+                    iface = ""
                     if router := addresses.get("Router"):
                         gateways.add(router)
+
                     if addresses.get("ConfigMethod", "") == "DHCP":
-                        ips.add(self._plistlease(name).get("IPAddress"))
+                        iface = self._plistlease(name).get("IPAddress")
                         dhcp = True
-                    else:
-                        for addr in addresses.get("Addresses", []):
-                            ips.add(addr)
+                    elif addr := addresses.get("Addresses", []):
+                        iface = addr[0]
+
+                    if _subnet_mask := list(filter(None, addresses.get("SubnetMasks", []))):
+                        iface = f"{iface}/{_subnet_mask[0]}"
 
-                if subnetmask:
-                    network = self.calculate_network(ips, subnetmask)
+                    if iface:
+                        ifaces.add(iface)
 
                 yield MacInterfaceRecord(
                     name=name,
                     type=_type,
                     enabled=not interface.get("__INACTIVE__", False),
-                    dns=list(dns),
-                    ip=list(ips),
+                    cidr=ifaces,
                     gateway=list(gateways),
+                    dns=list(dns),
+                    mac=[],
                     source="NetworkServices",
-                    vlan=vlan,
-                    network=network,
                     interface_service_order=interface_service_order,
                     dhcp=dhcp,
-                    mac=[],
+                    vlan=vlan,
                     _target=self.target,
                 )
 

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

@@ -81,21 +81,22 @@ class NetworkManagerConfigParser(LinuxNetworkConfigParser):
         dhcp_ipv6: bool = False
         vlan: set[int] = field(default_factory=set)
 
-        def to_record(self) -> UnixInterfaceRecord:
+        def to_record(self, target: Target) -> UnixInterfaceRecord:
             return UnixInterfaceRecord(
-                source=self.source,
-                last_connected=self.last_connected,
                 name=self.name,
-                mac=to_list(self.mac_address),
                 type=self.type,
+                enabled=None,
+                cidr=self.ip_interfaces,
+                gateway=list(self.gateways),
+                dns=list(self.dns),
+                mac=to_list(self.mac_address),
+                source=self.source,
                 dhcp_ipv4=self.dhcp_ipv4,
                 dhcp_ipv6=self.dhcp_ipv6,
-                dns=list(self.dns),
-                ip=[interface.ip for interface in self.ip_interfaces],
-                network=[interface.network for interface in self.ip_interfaces],
-                gateway=list(self.gateways),
+                last_connected=self.last_connected,
                 vlan=list(self.vlan),
                 configurator="NetworkManager",
+                _target=target,
             )
 
     def interfaces(self) -> Iterator[UnixInterfaceRecord]:
@@ -138,7 +139,7 @@ class NetworkManagerConfigParser(LinuxNetworkConfigParser):
             vlan_ids_from_uuid = vlan_id_by_interface.get(connection.uuid, set())
             connection.vlan.update(vlan_ids_from_uuid)
 
-            yield connection.to_record()
+            yield connection.to_record(self._target)
 
     def _parse_route(self, route: str) -> NetAddress | None:
         """Parse a route and return gateway IP address."""
@@ -284,19 +285,19 @@ class SystemdNetworkConfigParser(LinuxNetworkConfigParser):
                 dhcp_ipv4, dhcp_ipv6 = self._parse_dhcp(network_section.get("DHCP"))
 
                 yield UnixInterfaceRecord(
-                    source=str(config_file),
+                    name=match_section.get("Name"),
                     type=match_section.get("Type"),
                     enabled=None,  # Unknown, dependent on run-time state
-                    dhcp_ipv4=dhcp_ipv4,
-                    dhcp_ipv6=dhcp_ipv6,
-                    name=match_section.get("Name"),
+                    cidr=ip_interfaces,
+                    gateway=list(gateways),
                     dns=list(dns),
                     mac=list(mac_addresses),
-                    ip=[interface.ip for interface in ip_interfaces],
-                    network=[interface.network for interface in ip_interfaces],
-                    gateway=list(gateways),
+                    source=str(config_file),
+                    dhcp_ipv4=dhcp_ipv4,
+                    dhcp_ipv6=dhcp_ipv6,
                     vlan=list(vlan_ids),
                     configurator="systemd-networkd",
+                    _target=self._target,
                 )
             except Exception as e:
                 self._target.log.warning("Error parsing network config file %s", config_file)

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9}/dissect/target/plugins/os/windows/network.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from enum import IntEnum
 from functools import lru_cache
-from typing import Iterator
+from typing import TYPE_CHECKING
 
 from dissect.util.ts import wintimestamp
 
@@ -12,9 +12,13 @@ from dissect.target.exceptions import (
     RegistryValueNotFoundError,
 )
 from dissect.target.helpers.record import WindowsInterfaceRecord
-from dissect.target.helpers.regutil import RegistryKey
 from dissect.target.plugins.os.default.network import NetworkPlugin
-from dissect.target.target import Target
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.helpers.regutil import RegistryKey
+    from dissect.target.target import Target
 
 
 class IfTypes(IntEnum):
@@ -238,6 +242,20 @@ def _get_config_value(key: RegistryKey, name: str, sep: str | None = None) -> se
     return {value}
 
 
+def _construct_interface(key: RegistryKey, ip_key: str, subnet_key: str) -> set[str]:
+    interface = ""
+    if ip := _get_config_value(key, ip_key):
+        interface = next(iter(ip))
+
+    if subnet := _get_config_value(key, subnet_key):
+        interface = f"{interface}/{next(iter(subnet))}"
+
+    if not interface:
+        return set()
+
+    return {interface}
+
+
 class WindowsNetworkPlugin(NetworkPlugin):
     """Windows network interface plugin."""
 
@@ -300,10 +318,9 @@ class WindowsNetworkPlugin(NetworkPlugin):
                     # skip this network interface.
                     if not conf or not any(
                         [
-                            conf["dns"],
-                            conf["ip"],
+                            conf["cidr"],
                             conf["gateway"],
-                            conf["subnetmask"],
+                            conf["dns"],
                             conf["search_domain"],
                         ]
                     ):
@@ -322,21 +339,17 @@ class WindowsNetworkPlugin(NetworkPlugin):
         """Extract network device configuration from the given interface_id for all ControlSets on the system."""
 
         dhcp_config = {
+            "cidr": set(),
             "gateway": set(),
-            "ip": set(),
             "dns": set(),
-            "subnetmask": set(),
             "search_domain": set(),
-            "network": set(),
         }
 
         static_config = {
-            "ip": set(),
+            "cidr": set(),
+            "gateway": set(),
             "dns": set(),
-            "subnetmask": set(),
             "search_domain": set(),
-            "gateway": set(),
-            "network": set(),
         }
 
         # Get the registry keys for the given interface id
@@ -349,36 +362,27 @@ class WindowsNetworkPlugin(NetworkPlugin):
         except RegistryKeyNotFoundError:
             return []
 
-        if not len(keys):
+        if not keys:
             return []
 
         for key in keys:
             # Extract DHCP configuration from the registry
+            dhcp_config["cidr"].update(_construct_interface(key, "DhcpIPAddress", "DhcpSubnetMask"))
             dhcp_config["gateway"].update(_get_config_value(key, "DhcpDefaultGateway"))
-            dhcp_config["ip"].update(_get_config_value(key, "DhcpIPAddress"))
-            dhcp_config["subnetmask"].update(_get_config_value(key, "DhcpSubnetMask"))
-            dhcp_config["search_domain"].update(_get_config_value(key, "DhcpDomain"))
             dhcp_config["dns"].update(_get_config_value(key, "DhcpNameServer", " ,"))
+            dhcp_config["search_domain"].update(_get_config_value(key, "DhcpDomain"))
 
             # Extract static configuration from the registry
+            static_config["cidr"].update(_construct_interface(key, "IPAddress", "SubnetMask"))
             static_config["gateway"].update(_get_config_value(key, "DefaultGateway"))
             static_config["dns"].update(_get_config_value(key, "NameServer", " ,"))
             static_config["search_domain"].update(_get_config_value(key, "Domain"))
-            static_config["ip"].update(_get_config_value(key, "IPAddress"))
-            static_config["subnetmask"].update(_get_config_value(key, "SubnetMask"))
-
-        if len(dhcp_config) > 0:
-            dhcp_config["enabled"] = _try_value(key, "EnableDHCP") == 1
-            dhcp_config["dhcp"] = True
 
-        if len(static_config) > 0:
-            static_config["enabled"] = None
-            static_config["dhcp"] = False
+        dhcp_config["enabled"] = _try_value(key, "EnableDHCP") == 1
+        dhcp_config["dhcp"] = True
 
-        # Iterate over combined ip/subnet lists
-        for config in (dhcp_config, static_config):
-            if (ips := config.get("ip")) and (masks := config.get("subnetmask")):
-                config["network"].update(set(self.calculate_network(ips, masks)))
+        static_config["enabled"] = None
+        static_config["dhcp"] = False
 
         # Return both configurations
         return [dhcp_config, static_config]

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9}/dissect/target/tools/shell.py

@@ -306,9 +306,10 @@ class ExtendedCmd(cmd.Cmd):
 
     def do_man(self, line: str) -> bool:
         """alias for help"""
-        return self.do_help(line)
+        self.do_help(line)
+        return False
 
-    def complete_man(self, *args) -> list[str]:
+    def complete_man(self, *args: list[str]) -> list[str]:
         return cmd.Cmd.complete_help(self, *args)
 
     def do_unalias(self, line: str) -> bool:
@@ -403,16 +404,16 @@ class TargetCmd(ExtendedCmd):
             self.histfile = pathlib.Path(getattr(target._config, "HISTFILE", self.DEFAULT_HISTFILE)).expanduser()
 
         # prompt format
+        self.prompt_ps1 = "{BOLD_GREEN}{base}{RESET}:{BOLD_BLUE}{cwd}{RESET}$ "
         if ps1 := getattr(target._config, "PS1", None):
             if "{cwd}" in ps1 and "{base}" in ps1:
                 self.prompt_ps1 = ps1
+            else:
+                self.target.log.warning("{cwd} and {base} were not set inside PS1, using the default prompt")
 
         elif getattr(target._config, "NO_COLOR", None) or os.getenv("NO_COLOR"):
             self.prompt_ps1 = "{base}:{cwd}$ "
 
-        else:
-            self.prompt_ps1 = "{BOLD_GREEN}{base}{RESET}:{BOLD_BLUE}{cwd}{RESET}$ "
-
         super().__init__(self.target.props.get("cyber"))
 
     def _get_targetrc_path(self) -> pathlib.Path:

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev7
+Version: 3.22.dev9
 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.dev7 → dissect_target-3.22.dev9}/tests/plugins/general/test_network.py

@@ -17,10 +17,10 @@ def network_record(request: pytest.FixtureRequest) -> InterfaceRecord:
         name="interface_name",
         type="physical",
         enabled=True,
-        mac=["DE:AD:BE:EF:00:00"],
-        ip=["10.42.42.10"],
+        cidr=["10.42.42.10/24"],
         gateway=["10.42.42.1"],
         dns=["8.8.8.8", "1.1.1.1"],
+        mac=["DE:AD:BE:EF:00:00"],
         source="some_file",
     )
 

{dissect_target-3.22.dev7 → dissect_target-3.22.dev9}/tests/plugins/os/unix/bsd/osx/test_network.py

@@ -1,4 +1,3 @@
-from typing import Iterator
 from unittest import mock
 
 import pytest
@@ -8,13 +7,13 @@ from dissect.target.target import Target
 
 
 @pytest.fixture
-def almost_empty_plist() -> Iterator[dict]:
-    yield {"CurrentSet": {}}
+def almost_empty_plist() -> dict:
+    return {"CurrentSet": {}}
 
 
 @pytest.fixture
-def fake_plist() -> Iterator[dict]:
-    yield {
+def fake_plist() -> dict:
+    return {
         "CurrentSet": "/Sets/1",
         "NetworkServices": {
             "1": {
@@ -41,62 +40,61 @@ def fake_plist() -> Iterator[dict]:
 
 
 @pytest.fixture
-def vlan0(fake_plist: dict) -> Iterator[dict]:
+def vlan0(fake_plist: dict) -> dict:
     fake_plist["NetworkServices"]["1"]["Interface"].update({"DeviceName": "vlan0"})
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.fixture
-def inactive(fake_plist: dict) -> Iterator[dict]:
+def inactive(fake_plist: dict) -> dict:
     fake_plist["NetworkServices"]["1"].update({"__INACTIVE__": True})
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.fixture
-def ipv6(fake_plist: dict) -> Iterator[dict]:
+def ipv6(fake_plist: dict) -> dict:
     del fake_plist["NetworkServices"]["1"]["IPv4"]
     fake_plist["NetworkServices"]["1"]["IPv6"] = {"Addresses": ["::1"]}
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.fixture
-def reorder(fake_plist: dict) -> Iterator[dict]:
+def reorder(fake_plist: dict) -> dict:
     fake_plist["Sets"]["1"]["Network"]["Global"]["IPv4"]["ServiceOrder"] = ["2", "1"]
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.fixture
-def double(fake_plist: dict) -> Iterator[dict]:
+def double(fake_plist: dict) -> dict:
     fake_plist["NetworkServices"]["2"] = fake_plist["NetworkServices"]["1"]
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.fixture
-def dhcp(fake_plist: dict) -> Iterator[dict]:
+def dhcp(fake_plist: dict) -> dict:
     fake_plist["NetworkServices"]["1"]["IPv4"].update({"ConfigMethod": "DHCP"})
-    yield fake_plist
+    return fake_plist
 
 
 @pytest.mark.parametrize(
-    "lease,netinfo_param,expected,count",
+    ("lease", "netinfo_param", "expected", "count"),
     [
         ({"IPAddress": None}, "almost_empty_plist", [], 0),
         (
             {},
             "fake_plist",
             [
-                (0, "hostname", ["dummys Mac"]),
-                (0, "domain", ["None"]),
                 (0, "name", ["en0"]),
                 (0, "type", ["Ethernet"]),
-                (0, "ip", ["192.122.13.34"]),
+                (0, "enabled", ["True"]),
+                (0, "cidr", ["192.122.13.34/32"]),
+                (0, "hostname", ["dummys Mac"]),
                 (0, "gateway", ["8.8.8.8"]),
                 (0, "dns", ["8.8.8.8"]),
-                (0, "vlan", ["None"]),
-                (0, "enabled", ["True"]),
-                (0, "interface_service_order", ["0"]),
                 (0, "mac", []),
+                (0, "interface_service_order", ["0"]),
                 (0, "vlan", ["None"]),
+                (0, "domain", ["None"]),
             ],
             1,
         ),
@@ -104,7 +102,7 @@ def dhcp(fake_plist: dict) -> Iterator[dict]:
             {"IPAddress": "10.0.0.2"},
             "dhcp",
             [
-                (0, "ip", sorted(["10.0.0.2"])),
+                (0, "cidr", sorted(["10.0.0.2/32"])),
             ],
             1,
         ),
@@ -128,7 +126,7 @@ def dhcp(fake_plist: dict) -> Iterator[dict]:
             {},
             "ipv6",
             [
-                (0, "ip", ["::1"]),
+                (0, "cidr", ["::1/128"]),
             ],
             1,
         ),
@@ -155,10 +153,11 @@ def test_macos_network(
     target_osx: Target, lease: dict, netinfo_param: str, expected: dict, count: int, request: pytest.FixtureRequest
 ) -> None:
     plistnetwork = request.getfixturevalue(netinfo_param)
-    with mock.patch(
-        "dissect.target.plugins.os.unix.bsd.osx.network.MacNetworkPlugin._plistlease", return_value=lease
-    ), mock.patch(
-        "dissect.target.plugins.os.unix.bsd.osx.network.MacNetworkPlugin._plistnetwork", return_value=plistnetwork
+    with (
+        mock.patch("dissect.target.plugins.os.unix.bsd.osx.network.MacNetworkPlugin._plistlease", return_value=lease),
+        mock.patch(
+            "dissect.target.plugins.os.unix.bsd.osx.network.MacNetworkPlugin._plistnetwork", return_value=plistnetwork
+        ),
     ):
         network = MacNetworkPlugin(target_osx)
 
@@ -168,5 +167,5 @@ def test_macos_network(
         attr = getattr(interfaces[index], key)
         if not isinstance(attr, list):
             attr = [attr]
-        attr = list(sorted(map(str, attr)))
+        attr = sorted(map(str, attr))
         assert attr == value