dissect.target 3.20.dev49__tar.gz → 3.20.dev51__tar.gz

{dissect_target-3.20.dev49/dissect.target.egg-info → dissect_target-3.20.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.20.dev49
+Version: 3.20.dev51
 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
@@ -31,7 +31,7 @@ Requires-Dist: dissect.ntfs<4,>=3.4
 Requires-Dist: dissect.regf<4,>=3.3
 Requires-Dist: dissect.util<4,>=3
 Requires-Dist: dissect.volume<4,>=2
-Requires-Dist: flow.record~=3.16.0
+Requires-Dist: flow.record~=3.17.0
 Requires-Dist: structlog
 Provides-Extra: full
 Requires-Dist: asn1crypto; extra == "full"

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/container.py

@@ -239,7 +239,7 @@ def open(item: Union[list, str, BinaryIO, Path], *args, **kwargs):
                 log.info("Failed to import %s", container)
                 log.debug("", exc_info=e)
             except Exception as e:
-                raise ContainerError(f"Failed to open container {item}", cause=e)
+                raise ContainerError(f"Failed to open container {item}") from e
     finally:
         if first_fh_opened:
             first_fh.close()

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/exceptions.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 import traceback
@@ -7,13 +9,12 @@ from typing import Callable
 class Error(Exception):
     """Generic dissect.target error"""
 
-    def __init__(self, message=None, cause=None, extra=None):
+    def __init__(self, message: str | None = None, extra: list[Exception] | None = None):
         if extra:
             exceptions = "\n\n".join(["".join(traceback.format_exception_only(type(e), e)) for e in extra])
             message = f"{message}\n\nAdditionally, the following exceptions occurred:\n\n{exceptions}"
 
         super().__init__(message)
-        self.__cause__ = cause
         self.__extra__ = extra
 
 

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystem.py

@@ -1142,7 +1142,7 @@ class VirtualFilesystem(Filesystem):
                     try:
                         return entry.top.get(fsutil.join(*parts[i:], alt_separator=self.alt_separator))
                     except FilesystemError as e:
-                        raise FileNotFoundError(full_path, cause=e)
+                        raise FileNotFoundError(full_path) from e
                 else:
                     raise FileNotFoundError(full_path)
 
@@ -1715,7 +1715,7 @@ def open(fh: BinaryIO, *args, **kwargs) -> Filesystem:
                 log.info("Failed to import %s", filesystem)
                 log.debug("", exc_info=e)
             except Exception as e:
-                raise FilesystemError(f"Failed to open filesystem for {fh}", cause=e)
+                raise FilesystemError(f"Failed to open filesystem for {fh}") from e
     finally:
         fh.seek(offset)
 

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/btrfs.py

@@ -79,13 +79,13 @@ class BtrfsSubvolumeFilesystem(Filesystem):
         try:
             return self.subvolume.get(path, node)
         except btrfs.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except btrfs.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except btrfs.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except btrfs.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class BtrfsFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/extfs.py

@@ -33,13 +33,13 @@ class ExtFilesystem(Filesystem):
         try:
             return self.extfs.get(path, node)
         except extfs.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except extfs.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except extfs.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except extfs.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class ExtFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/fat.py

@@ -41,11 +41,11 @@ class FatFilesystem(Filesystem):
         try:
             return self.fatfs.get(path, dirent=entry)
         except fat_exc.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except fat_exc.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except fat_exc.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class FatFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/ffs.py

@@ -39,13 +39,13 @@ class FfsFilesystem(Filesystem):
         try:
             return self.ffs.get(path, node)
         except ffs.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except ffs.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except ffs.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except ffs.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class FfsFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/jffs.py

@@ -35,13 +35,13 @@ class JFFSFilesystem(Filesystem):
         try:
             return self.jffs2.get(path, node)
         except jffs2.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except jffs2.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except jffs2.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except jffs2.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class JFFSFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/ntfs.py

@@ -48,12 +48,12 @@ class NtfsFilesystem(Filesystem):
         try:
             path = path.rsplit(":", maxsplit=1)[0]
             return self.ntfs.mft.get(path, root=root)
-        except NtfsFileNotFoundError:
-            raise FileNotFoundError(path)
+        except NtfsFileNotFoundError as e:
+            raise FileNotFoundError(path) from e
         except NtfsNotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except NtfsError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class NtfsFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/smb.py

@@ -58,10 +58,10 @@ class SmbFilesystem(Filesystem):
         except SessionError as e:
             if e.error == STATUS_NOT_A_DIRECTORY:
                 # STATUS_NOT_A_DIRECTORY
-                raise NotADirectoryError(path, cause=e)
+                raise NotADirectoryError(path) from e
             else:
                 # 0xC000000F is STATUS_NO_SUCH_FILE, but everything else should raise a FileNotFoundError anyway
-                raise FileNotFoundError(path, cause=e)
+                raise FileNotFoundError(path) from e
 
         if len(result) != 1:
             raise FileNotFoundError(path)
@@ -106,7 +106,7 @@ class SmbFilesystemEntry(FilesystemEntry):
         try:
             return SmbStream(self.fs.conn, self.fs.share_name, self.path, self.entry.get_filesize())
         except SessionError as e:
-            raise FilesystemError(f"Failed to open file: {self.path}", cause=e)
+            raise FilesystemError(f"Failed to open file: {self.path}") from e
 
     def is_dir(self, follow_symlinks: bool = True) -> bool:
         try:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/squashfs.py

@@ -32,13 +32,13 @@ class SquashFSFilesystem(Filesystem):
         try:
             return self.squashfs.get(path, node)
         except exceptions.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except exceptions.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except exceptions.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except exceptions.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class SquashFSFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/vmfs.py

@@ -41,13 +41,13 @@ class VmfsFilesystem(Filesystem):
         try:
             return self.vmfs.get(path, node)
         except vmfs.FileNotFoundError as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
         except vmfs.NotADirectoryError as e:
-            raise NotADirectoryError(path, cause=e)
+            raise NotADirectoryError(path) from e
         except vmfs.NotASymlinkError as e:
-            raise NotASymlinkError(path, cause=e)
+            raise NotASymlinkError(path) from e
         except vmfs.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class VmfsFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/filesystems/xfs.py

@@ -35,14 +35,14 @@ class XfsFilesystem(Filesystem):
     def _get_node(self, path: str, node: Optional[xfs.INode] = None) -> xfs.INode:
         try:
             return self.xfs.get(path, node)
-        except xfs.FileNotFoundError:
-            raise FileNotFoundError(path)
-        except xfs.NotADirectoryError:
-            raise NotADirectoryError(path)
-        except xfs.NotASymlinkError:
-            raise NotASymlinkError(path)
+        except xfs.FileNotFoundError as e:
+            raise FileNotFoundError(path) from e
+        except xfs.NotADirectoryError as e:
+            raise NotADirectoryError(path) from e
+        except xfs.NotASymlinkError as e:
+            raise NotASymlinkError(path) from e
         except xfs.Error as e:
-            raise FileNotFoundError(path, cause=e)
+            raise FileNotFoundError(path) from e
 
 
 class XfsFilesystemEntry(FilesystemEntry):

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/helpers/regutil.py

@@ -1,4 +1,5 @@
-""" Registry related abstractions """
+"""Registry related abstractions"""
+
 from __future__ import annotations
 
 import fnmatch
@@ -645,7 +646,7 @@ class RegfHive(RegistryHive):
         try:
             return RegfKey(self, self.hive.open(key))
         except regf.RegistryKeyNotFoundError as e:
-            raise RegistryKeyNotFoundError(key, cause=e)
+            raise RegistryKeyNotFoundError(key) from e
 
 
 class RegfKey(RegistryKey):
@@ -675,7 +676,7 @@ class RegfKey(RegistryKey):
         try:
             return RegfKey(self.hive, self.key.subkey(subkey))
         except regf.RegistryKeyNotFoundError as e:
-            raise RegistryKeyNotFoundError(subkey, cause=e)
+            raise RegistryKeyNotFoundError(subkey) from e
 
     def subkeys(self) -> list[RegistryKey]:
         return [RegfKey(self.hive, k) for k in self.key.subkeys()]
@@ -684,7 +685,7 @@ class RegfKey(RegistryKey):
         try:
             return RegfValue(self.hive, self.key.value(value))
         except regf.RegistryValueNotFoundError as e:
-            raise RegistryValueNotFoundError(value, cause=e)
+            raise RegistryValueNotFoundError(value) from e
 
     def values(self) -> list[RegistryValue]:
         return [RegfValue(self.hive, v) for v in self.key.values()]

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugin.py

@@ -807,7 +807,7 @@ def load(plugin_desc: PluginDescriptor) -> Type[Plugin]:
         module = importlib.import_module(module)
         return getattr(module, plugin_desc["class"])
     except Exception as e:
-        raise PluginError(f"An exception occurred while trying to load a plugin: {module}", cause=e)
+        raise PluginError(f"An exception occurred while trying to load a plugin: {module}") from e
 
 
 def failed() -> list[dict[str, Any]]:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugins/general/network.py

@@ -53,22 +53,22 @@ class NetworkPlugin(Plugin):
     @export
     def ips(self) -> list[IPAddress]:
         """Return IP addresses as list of :class:`IPAddress`."""
-        return list(self._get_record_type("ip"))
+        return list(set(self._get_record_type("ip")))
 
     @export
     def gateways(self) -> list[IPAddress]:
         """Return gateways as list of :class:`IPAddress`."""
-        return list(self._get_record_type("gateway"))
+        return list(set(self._get_record_type("gateway")))
 
     @export
     def macs(self) -> list[str]:
         """Return MAC addresses as list of :class:`str`."""
-        return list(self._get_record_type("mac"))
+        return list(set(self._get_record_type("mac")))
 
     @export
-    def dns(self) -> list[str]:
+    def dns(self) -> list[str | IPAddress]:
         """Return DNS addresses as list of :class:`str`."""
-        return list(self._get_record_type("dns"))
+        return list(set(self._get_record_type("dns")))
 
     @internal
     def with_ip(self, ip_addr: str) -> Iterator[InterfaceRecord]:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugins/os/unix/bsd/osx/_os.py

@@ -41,10 +41,7 @@ class MacPlugin(BsdPlugin):
 
     @export(property=True)
     def ips(self) -> Optional[list[str]]:
-        ips = set()
-        for ip in self.target.network.ips():
-            ips.add(str(ip))
-        return list(ips)
+        return list(set(map(str, self.target.network.ips())))
 
     @export(property=True)
     def version(self) -> Optional[str]:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugins/os/unix/linux/_os.py

@@ -34,17 +34,15 @@ class LinuxPlugin(UnixPlugin, LinuxNetworkManager):
     @export(property=True)
     def ips(self) -> list[str]:
         """Returns a list of static IP addresses and DHCP lease IP addresses found on the host system."""
-        ips = []
+        ips = set()
 
         for ip_set in self.network_manager.get_config_value("ips"):
-            for ip in ip_set:
-                ips.append(ip)
+            ips.update(ip_set)
 
         for ip in parse_unix_dhcp_log_messages(self.target, iter_all=False):
-            if ip not in ips:
-                ips.append(ip)
+            ips.add(ip)
 
-        return ips
+        return list(ips)
 
     @export(property=True)
     def dns(self) -> list[str]:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugins/os/windows/_os.py

@@ -109,7 +109,7 @@ class WindowsPlugin(OSPlugin):
 
     @export(property=True)
     def ips(self) -> list[str]:
-        return self.target.network.ips()
+        return list(set(map(str, self.target.network.ips())))
 
     def _get_version_reg_value(self, value_name: str) -> Any:
         try:

{dissect_target-3.20.dev49 → dissect_target-3.20.dev51}/dissect/target/plugins/os/windows/network.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from enum import IntEnum
+from functools import lru_cache
 from typing import Iterator
 
 from dissect.util.ts import wintimestamp
@@ -12,6 +13,7 @@ from dissect.target.exceptions import (
 from dissect.target.helpers.record import WindowsInterfaceRecord
 from dissect.target.helpers.regutil import RegistryKey
 from dissect.target.plugins.general.network import NetworkPlugin
+from dissect.target.target import Target
 
 
 class IfTypes(IntEnum):
@@ -222,15 +224,32 @@ def _try_value(subkey: RegistryKey, value: str) -> str | list | None:
         return None
 
 
+def _get_config_value(key: RegistryKey, name: str) -> set:
+    value = _try_value(key, name)
+    if not value or value in ("", "0.0.0.0", None, [], ["0.0.0.0"]):
+        return set()
+
+    if isinstance(value, list):
+        return set(value)
+
+    return {value}
+
+
 class WindowsNetworkPlugin(NetworkPlugin):
     """Windows network interface plugin."""
 
+    def __init__(self, target: Target):
+        super().__init__(target)
+        self._extract_network_device_config = lru_cache(128)(self._extract_network_device_config)
+
     def _interfaces(self) -> Iterator[WindowsInterfaceRecord]:
+        """Yields found Windows interfaces used by :meth:`NetworkPlugin.interfaces() <dissect.target.plugins.general.network.NetworkPlugin.interfaces>`."""  # noqa: E501
+
         # Get all the network interfaces
-        for keys in self.target.registry.keys(
+        for key in self.target.registry.keys(
             "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Class\\{4d36e972-e325-11ce-bfc1-08002be10318}"
         ):
-            for subkey in keys.subkeys():
+            for subkey in key.subkeys():
                 device_info = {}
 
                 if (net_cfg_instance_id := _try_value(subkey, "NetCfgInstanceId")) is None:
@@ -239,24 +258,26 @@ class WindowsNetworkPlugin(NetworkPlugin):
 
                 # Extract the network device configuration for given interface id
                 config = self._extract_network_device_config(net_cfg_instance_id)
-                if config is None or all(not conf for conf in config):
-                    # if no configuration is found or all configurations are empty, skip this network interface
-                    continue
 
-                # Extract the network device name for given interface id
-                name_key = self.target.registry.key(
-                    f"HKLM\\SYSTEM\\CurrentControlSet\\Control\\Network\\"
-                    f"{{4D36E972-E325-11CE-BFC1-08002BE10318}}\\{net_cfg_instance_id}\\Connection"
-                )
-                if value_name := _try_value(name_key, "Name"):
-                    device_info["name"] = value_name
-
-                # Extract the metric value from the REGISTRY_KEY_INTERFACE key
-                interface_key = self.target.registry.key(
-                    f"HKLM\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\{net_cfg_instance_id}"
-                )
-                if value_metric := _try_value(interface_key, "InterfaceMetric"):
-                    device_info["metric"] = value_metric
+                # Extract a network device name for given interface id
+                try:
+                    name_key = self.target.registry.key(
+                        f"HKLM\\SYSTEM\\CurrentControlSet\\Control\\Network\\{{4D36E972-E325-11CE-BFC1-08002BE10318}}\\{net_cfg_instance_id}\\Connection"  # noqa: E501
+                    )
+                    if value_name := _try_value(name_key, "Name"):
+                        device_info["name"] = value_name
+                except RegistryKeyNotFoundError:
+                    pass
+
+                # Extract the metric value from the interface registry key
+                try:
+                    interface_key = self.target.registry.key(
+                        f"HKLM\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\{net_cfg_instance_id}"  # noqa: E501
+                    )
+                    if value_metric := _try_value(interface_key, "InterfaceMetric"):
+                        device_info["metric"] = value_metric
+                except RegistryKeyNotFoundError:
+                    pass
 
                 # Extract the rest of the device information
                 device_info["mac"] = _try_value(subkey, "NetworkAddress")
@@ -270,26 +291,57 @@ class WindowsNetworkPlugin(NetworkPlugin):
 
                 # Yield a record for each non-empty configuration
                 for conf in config:
-                    if conf:
-                        # Create a copy of device_info to avoid overwriting
-                        record_info = device_info.copy()
-                        record_info.update(conf)
-                        yield WindowsInterfaceRecord(
-                            **record_info,
-                            source=f"HKLM\\SYSTEM\\{subkey.path}",
-                            _target=self.target,
-                        )
+                    # If no configuration is found or all configurations are empty,
+                    # skip this network interface.
+                    if not conf or not any(
+                        [
+                            conf["dns"],
+                            conf["ip"],
+                            conf["gateway"],
+                            conf["subnetmask"],
+                            conf["search_domain"],
+                        ]
+                    ):
+                        continue
+
+                    # Create a copy of device_info to avoid overwriting
+                    record_info = device_info.copy()
+                    record_info.update(conf)
+                    yield WindowsInterfaceRecord(
+                        **record_info,
+                        source=f"HKLM\\SYSTEM\\{subkey.path}",
+                        _target=self.target,
+                    )
 
     def _extract_network_device_config(
         self, interface_id: str
     ) -> list[dict[str, str | list], dict[str, str | list]] | None:
-        dhcp_config = {}
-        static_config = {}
+        """Extract network device configuration from the given interface_id for all ControlSets on the system."""
+
+        dhcp_config = {
+            "gateway": set(),
+            "ip": set(),
+            "dns": set(),
+            "subnetmask": set(),
+            "search_domain": set(),
+            "network": set(),
+        }
+
+        static_config = {
+            "ip": set(),
+            "dns": set(),
+            "subnetmask": set(),
+            "search_domain": set(),
+            "gateway": set(),
+            "network": set(),
+        }
 
         # Get the registry keys for the given interface id
         try:
-            keys = self.target.registry.key(
-                f"HKLM\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\{interface_id}"
+            keys = list(
+                self.target.registry.keys(
+                    f"HKLM\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\{interface_id}"
+                )
             )
         except RegistryKeyNotFoundError:
             return None
@@ -297,69 +349,33 @@ class WindowsNetworkPlugin(NetworkPlugin):
         if not len(keys):
             return None
 
-        # Extract DHCP configuration from the registry
-        dhcp_gateway = _try_value(keys, "DhcpDefaultGateway")
-        if dhcp_gateway not in ["", "0.0.0.0", None, []]:
-            dhcp_config["gateway"] = dhcp_gateway
-
-        dhcp_ip = _try_value(keys, "DhcpIPAddress")
-        if dhcp_ip not in ["", "0.0.0.0", None]:
-            dhcp_config["ip"] = [dhcp_ip]
-
-        dhcp_dns = _try_value(keys, "DhcpNameServer")
-        if dhcp_dns not in ["", "0.0.0.0", None]:
-            dhcp_config["dns"] = dhcp_dns.split(" ")
-
-        dhcp_subnetmask = _try_value(keys, "DhcpSubnetMask")
-        if dhcp_subnetmask not in ["", "0.0.0.0", None]:
-            dhcp_config["subnetmask"] = [dhcp_subnetmask]
-
-        dhcp_domain = _try_value(keys, "DhcpDomain")
-        if dhcp_domain not in ["", None]:
-            dhcp_config["search_domain"] = [dhcp_domain]
+        for key in keys:
+            # Extract DHCP configuration from the registry
+            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"))
+
+            # Extract static configuration from the registry
+            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_enable = _try_value(keys, "EnableDHCP")
-            dhcp_config["enabled"] = dhcp_enable == 1
+            dhcp_config["enabled"] = _try_value(key, "EnableDHCP") == 1
             dhcp_config["dhcp"] = True
 
-        # Extract static configuration from the registry
-        static_gateway = _try_value(keys, "DefaultGateway")
-        if static_gateway not in ["", None, []]:
-            static_config["gateway"] = static_gateway
-
-        static_ip = _try_value(keys, "IPAddress")
-        if static_ip not in ["", "0.0.0.0", ["0.0.0.0"], None, []]:
-            static_config["ip"] = static_ip if isinstance(static_ip, list) else [static_ip]
-
-        static_dns = _try_value(keys, "NameServer")
-        if static_dns not in ["", "0.0.0.0", None]:
-            static_config["dns"] = static_dns.split(",")
-
-        static_subnetmask = _try_value(keys, "SubnetMask")
-        if static_subnetmask not in ["", "0.0.0.0", ["0.0.0.0"], None, []]:
-            static_config["subnetmask"] = (
-                static_subnetmask if isinstance(static_subnetmask, list) else [static_subnetmask]
-            )
-
-        static_domain = _try_value(keys, "Domain")
-        if static_domain not in ["", None]:
-            static_config["search_domain"] = [static_domain]
-
         if len(static_config) > 0:
             static_config["enabled"] = None
             static_config["dhcp"] = False
 
-        # Combine ip and subnetmask for extraction
-        combined_configs = [
-            (dhcp_config, dhcp_config.get("ip", []), dhcp_config.get("subnetmask", [])),
-            (static_config, static_config.get("ip", []), static_config.get("subnetmask", [])),
-        ]
-
         # Iterate over combined ip/subnet lists
-        for config, ips, subnet_masks in combined_configs:
-            for network_address in self.calculate_network(ips, subnet_masks):
-                config.setdefault("network", []).append(network_address)
+        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)))
 
         # Return both configurations
         return [dhcp_config, static_config]