dissect.target 3.19.dev29__tar.gz → 3.19.dev31__tar.gz

{dissect_target-3.19.dev29/dissect.target.egg-info → dissect_target-3.19.dev31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev29
+Version: 3.19.dev31
 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.dev29 → dissect_target-3.19.dev31}/dissect/target/filesystems/config.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import io
 import textwrap
 from logging import getLogger
-from typing import Any, BinaryIO, Iterator, Optional, Union
+from typing import Any, BinaryIO, Iterator, Optional
 
 from dissect.target import Target
 from dissect.target.exceptions import ConfigurationParsingError, FileNotFoundError
-from dissect.target.filesystem import Filesystem, FilesystemEntry, VirtualFilesystem
+from dissect.target.filesystem import FilesystemEntry, VirtualFilesystem
 from dissect.target.helpers import fsutil
 from dissect.target.helpers.configutil import ConfigurationParser, parse
 
@@ -46,7 +46,7 @@ class ConfigurationFilesystem(VirtualFilesystem):
         super().__init__(**kwargs)
         self.root.top = target.fs.get(path)
 
-    def _get_till_file(self, path: str, relentry: FilesystemEntry) -> tuple[list[str], FilesystemEntry]:
+    def _get_till_file(self, path: str, relentry: FilesystemEntry | None) -> tuple[list[str], FilesystemEntry]:
         """Searches for the file entry that is pointed to by ``path``.
 
         The ``path`` could contain ``key`` entries too, so it searches for the entry from
@@ -56,9 +56,13 @@ class ConfigurationFilesystem(VirtualFilesystem):
             A list of ``parts`` containing keys: [keys, into, the, file].
             And the resolved entry: Entry(filename)
         """
+
         entry = relentry or self.root
+        root_path = relentry.path if relentry else self.root.top.path
 
-        path = fsutil.normalize(path, alt_separator=self.alt_separator).strip("/")
+        # Calculate the relative path
+        relpath = fsutil.relpath(path, root_path, alt_separator=self.alt_separator)
+        path = fsutil.normalize(relpath, alt_separator=self.alt_separator).strip("/")
 
         if not path:
             return [], entry
@@ -85,10 +89,8 @@ class ConfigurationFilesystem(VirtualFilesystem):
 
         return parts[idx:], entry
 
-    def get(
-        self, path: str, relentry: Optional[FilesystemEntry] = None, *args, **kwargs
-    ) -> Union[FilesystemEntry, ConfigurationEntry]:
-        """Retrieve a :class:`ConfigurationEntry` or :class:`.FilesystemEntry` relative to the root or ``relentry``.
+    def get(self, path: str, relentry: Optional[FilesystemEntry] = None, *args, **kwargs) -> ConfigurationEntry:
+        """Retrieve a :class:`ConfigurationEntry` relative to the root or ``relentry``.
 
         Raises:
             FileNotFoundError: if it could not find the entry.
@@ -96,7 +98,7 @@ class ConfigurationFilesystem(VirtualFilesystem):
         parts, entry = self._get_till_file(path, relentry)
 
         if entry.is_dir():
-            return entry
+            return ConfigurationEntry(self, entry.path, entry, None)
 
         entry = self._convert_entry(entry, *args, **kwargs)
 
@@ -108,23 +110,21 @@ class ConfigurationFilesystem(VirtualFilesystem):
 
         return entry
 
-    def _convert_entry(
-        self, file_entry: FilesystemEntry, *args, **kwargs
-    ) -> Union[ConfigurationEntry, FilesystemEntry]:
+    def _convert_entry(self, file_entry: FilesystemEntry, *args, **kwargs) -> ConfigurationEntry:
         """Creates a :class:`ConfigurationEntry` from a ``file_entry``.
 
         If an error occurs during the parsing of the file contents,
         the original ``file_entry`` is returned.
         """
         entry = file_entry
+        config_parser = None
         try:
             config_parser = parse(entry, *args, **kwargs)
-            entry = ConfigurationEntry(self, entry.path, entry, config_parser)
         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)
 
-        return entry
+        return ConfigurationEntry(self, entry.path, entry, config_parser)
 
 
 class ConfigurationEntry(FilesystemEntry):
@@ -163,10 +163,10 @@ class ConfigurationEntry(FilesystemEntry):
 
     def __init__(
         self,
-        fs: Filesystem,
+        fs: ConfigurationFilesystem,
         path: str,
         entry: FilesystemEntry,
-        parser_items: Optional[Union[dict, ConfigurationParser, str, list]] = None,
+        parser_items: dict | ConfigurationParser | str | list | None = None,
     ) -> None:
         super().__init__(fs, path, entry)
         self.parser_items = parser_items
@@ -182,7 +182,7 @@ class ConfigurationEntry(FilesystemEntry):
 
         return f"<{self.__class__.__name__} {output}"
 
-    def get(self, key, default: Optional[Any] = None) -> Union[ConfigurationEntry, Any, None]:
+    def get(self, key, default: Any | None = None) -> ConfigurationEntry | Any | None:
         """Gets the dictionary key that belongs to this entry using ``key``.
         Behaves like ``dictionary.get()``.
 
@@ -197,13 +197,19 @@ class ConfigurationEntry(FilesystemEntry):
         if not key:
             raise TypeError("key should be defined")
 
-        if key in self.parser_items:
+        path = fsutil.join(self.path, key, alt_separator=self.fs.alt_separator)
+
+        if self.parser_items and key in self.parser_items:
             return ConfigurationEntry(
                 self.fs,
-                fsutil.join(self.path, key, alt_separator=self.fs.alt_separator),
+                path,
                 self.entry,
                 self.parser_items[key],
             )
+
+        if self.entry.is_dir():
+            return self.fs.get(path, self.entry)
+
         return default
 
     def _write_value_mapping(self, values: dict[str, Any], indentation_nr: int = 0) -> str:
@@ -257,6 +263,11 @@ class ConfigurationEntry(FilesystemEntry):
         if self.is_file():
             raise NotADirectoryError()
 
+        if self.parser_items is None and self.entry.is_dir():
+            for entry in self.entry.scandir():
+                yield ConfigurationEntry(self.fs, entry.name, entry, None)
+            return
+
         for key, values in self.parser_items.items():
             yield ConfigurationEntry(self.fs, key, self.entry, values)
 
@@ -266,7 +277,7 @@ class ConfigurationEntry(FilesystemEntry):
     def is_dir(self, follow_symlinks: bool = True) -> bool:
         """Returns whether this :class:`ConfigurationEntry` can be considered a directory."""
         # if self.parser_items has keys (thus sub-values), we can consider it a directory.
-        return hasattr(self.parser_items, "keys")
+        return (self.parser_items is None and self.entry.is_dir()) or hasattr(self.parser_items, "keys")
 
     def is_symlink(self) -> bool:
         """Return whether this :class:`ConfigurationEntry` is a symlink or not.
@@ -284,7 +295,7 @@ class ConfigurationEntry(FilesystemEntry):
         Returns:
             Whether the ``entry`` and ``key`` exists
         """
-        return self.entry.exists() and key in self.parser_items
+        return self.parser_items and self.entry.exists() and key in self.parser_items
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Returns the stat from the underlying :class:`.FilesystemEntry` :attr:`entry`."""

{dissect_target-3.19.dev29 → dissect_target-3.19.dev31}/dissect/target/helpers/configutil.py

@@ -171,7 +171,7 @@ class ConfigurationParser:
         try:
             self.parse_file(fh)
         except Exception as e:
-            raise ConfigurationParsingError(*e.args) from e
+            raise ConfigurationParsingError(e.args) from e
 
         if self.collapse_all or self.collapse:
             self.parsed_data = self._collapse_dict(self.parsed_data)

{dissect_target-3.19.dev29 → dissect_target-3.19.dev31}/dissect/target/plugins/os/unix/esxi/_os.py

@@ -8,7 +8,7 @@ import subprocess
 from configparser import ConfigParser
 from configparser import Error as ConfigParserError
 from io import BytesIO
-from typing import Any, BinaryIO, Iterator, Optional, TextIO
+from typing import Any, BinaryIO, Iterator, TextIO
 
 from defusedxml import ElementTree
 from dissect.hypervisor.util import vmtar
@@ -73,7 +73,7 @@ class ESXiPlugin(UnixPlugin):
         if configstore.exists():
             self._configstore = parse_config_store(configstore.open())
 
-    def _cfg(self, path: str) -> Optional[str]:
+    def _cfg(self, path: str) -> str | None:
         if not self._config:
             self.target.log.warning("No ESXi config!")
             return None
@@ -87,7 +87,7 @@ class ESXiPlugin(UnixPlugin):
         return obj.get(value_name) if obj else None
 
     @classmethod
-    def detect(cls, target: Target) -> Optional[Filesystem]:
+    def detect(cls, target: Target) -> Filesystem | None:
         bootbanks = [
             fs for fs in target.filesystems if fs.path("boot.cfg").exists() and list(fs.path("/").glob("*.v00"))
         ]
@@ -128,7 +128,7 @@ class ESXiPlugin(UnixPlugin):
         return "localhost"
 
     @export(property=True)
-    def domain(self) -> Optional[str]:
+    def domain(self) -> str | None:
         if hostname := self._cfg("/adv/Misc/HostName"):
             return hostname.partition(".")[2]
 
@@ -146,7 +146,7 @@ class ESXiPlugin(UnixPlugin):
         return list(result)
 
     @export(property=True)
-    def version(self) -> Optional[str]:
+    def version(self) -> str | None:
         boot_cfg = self.target.fs.path("/bootbank/boot.cfg")
         if not boot_cfg.exists():
             return None
@@ -187,11 +187,11 @@ class ESXiPlugin(UnixPlugin):
         return self._configstore
 
     @export(property=True)
-    def os(self):
+    def os(self) -> str:
         return OperatingSystem.ESXI.value
 
 
-def _mount_modules(target: Target, sysvol: Filesystem, cfg: dict[str, str]):
+def _mount_modules(target: Target, sysvol: Filesystem, cfg: dict[str, str]) -> None:
     modules = [m.strip() for m in cfg["modules"].split("---")]
 
     for module in modules:
@@ -218,20 +218,22 @@ def _mount_modules(target: Target, sysvol: Filesystem, cfg: dict[str, str]):
             target.fs.append_layer().mount("/", tfs)
 
 
-def _mount_local(target: Target, local_layer: VirtualFilesystem):
+def _mount_local(target: Target, local_layer: VirtualFilesystem) -> None:
     local_tgz = target.fs.path("local.tgz")
+    local_tgz_ve = target.fs.path("local.tgz.ve")
     local_fs = None
 
     if local_tgz.exists():
         local_fs = tar.TarFilesystem(local_tgz.open())
-    else:
-        local_tgz_ve = target.fs.path("local.tgz.ve")
+    elif local_tgz_ve.exists():
         # In the case "encryption.info" does not exist, but ".#encryption.info" does
         encryption_info = next(target.fs.path("/").glob("*encryption.info"), None)
         if not local_tgz_ve.exists() or not encryption_info.exists():
             raise ValueError("Unable to find valid configuration archive")
 
         local_fs = _create_local_fs(target, local_tgz_ve, encryption_info)
+    else:
+        target.log.warning("No local.tgz or local.tgz.ve found, skipping local state")
 
     if local_fs:
         local_layer.mount("/", local_fs)
@@ -245,7 +247,7 @@ def _decrypt_envelope(local_tgz_ve: TargetPath, encryption_info: TargetPath) ->
     return local_tgz
 
 
-def _decrypt_crypto_util(local_tgz_ve: TargetPath) -> Optional[BytesIO]:
+def _decrypt_crypto_util(local_tgz_ve: TargetPath) -> BytesIO | None:
     """Decrypt ``local.tgz.ve`` using ESXi ``crypto-util``.
 
     We write to stdout, but this results in ``crypto-util`` exiting with a non-zero return code
@@ -264,9 +266,7 @@ def _decrypt_crypto_util(local_tgz_ve: TargetPath) -> Optional[BytesIO]:
     return BytesIO(result.stdout)
 
 
-def _create_local_fs(
-    target: Target, local_tgz_ve: TargetPath, encryption_info: TargetPath
-) -> Optional[tar.TarFilesystem]:
+def _create_local_fs(target: Target, local_tgz_ve: TargetPath, encryption_info: TargetPath) -> tar.TarFilesystem | None:
     local_tgz = None
 
     if HAS_ENVELOPE:
@@ -292,7 +292,7 @@ def _create_local_fs(
         return tar.TarFilesystem(local_tgz)
 
 
-def _mount_filesystems(target: Target, sysvol: Filesystem, cfg: dict[str, str]):
+def _mount_filesystems(target: Target, sysvol: Filesystem, cfg: dict[str, str]) -> None:
     version = cfg["build"]
 
     osdata_fs = None
@@ -371,7 +371,7 @@ def _mount_filesystems(target: Target, sysvol: Filesystem, cfg: dict[str, str]):
         target.fs.symlink(f"/vmfs/volumes/LOCKER-{locker_fs.vmfs.uuid}", "/locker")
 
 
-def _link_log_dir(target: Target, cfg: dict[str, str], plugin_obj: ESXiPlugin):
+def _link_log_dir(target: Target, cfg: dict[str, str], plugin_obj: ESXiPlugin) -> None:
     version = cfg["build"]
 
     # Don't really know how ESXi does this, but let's just take a shortcut for now
@@ -441,7 +441,7 @@ def parse_esx_conf(fh: TextIO) -> dict[str, Any]:
     return config
 
 
-def _traverse(path: str, obj: dict[str, Any], create: bool = False):
+def _traverse(path: str, obj: dict[str, Any], create: bool = False) -> dict[str, Any] | None:
     parts = path.strip("/").split("/")
     path_parts = parts[:-1]
     for part in path_parts:

{dissect_target-3.19.dev29 → dissect_target-3.19.dev31}/dissect/target/plugins/os/unix/etc/etc.py

@@ -62,13 +62,13 @@ class EtcTree(ConfigurationTreePlugin):
 
     @export(record=UnixConfigTreeRecord)
     @arg("--glob", dest="pattern", required=False, default="*", type=str, help="Glob-style pattern to search for")
-    def etc(self, pattern: str) -> Iterator[UnixConfigTreeRecord]:
-        for entry, subs, items in self.config_fs.walk("/"):
+    @arg("--root", dest="root", required=False, default="/", type=str, help="Path to use as root for search")
+    def etc(self, pattern: str, root: str) -> Iterator[UnixConfigTreeRecord]:
+        for entry, subs, items in self.config_fs.walk(root):
             for item in items:
                 try:
                     config_object = self.get(str(Path(entry) / Path(item)))
-                    if isinstance(config_object, ConfigurationEntry):
-                        yield from self._sub(config_object, Path(entry) / Path(item), pattern)
+                    yield from self._sub(config_object, Path(entry) / Path(item), pattern)
                 except Exception:
                     self.target.log.warning("Could not open configuration item: %s", item)
                     pass

{dissect_target-3.19.dev29 → dissect_target-3.19.dev31/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev29
+Version: 3.19.dev31
 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.dev29 → dissect_target-3.19.dev31}/tests/filesystems/test_config.py

@@ -31,7 +31,7 @@ def mapped_file(test_file: str, fs_unix: VirtualFilesystem) -> VirtualFilesystem
     local_path = Path(absolute_path(test_file))
     file_name = f"/etc/{local_path.name}"
     fs_unix.map_file(file_name, local_path.absolute())
-    return local_path.name
+    return "/" + local_path.name
 
 
 @pytest.mark.parametrize(