dissect.target 3.19.dev30__tar.gz → 3.19.dev32__tar.gz

{dissect_target-3.19.dev30/dissect.target.egg-info → dissect_target-3.19.dev32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev30
+Version: 3.19.dev32
 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.dev30 → dissect_target-3.19.dev32}/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.dev30 → dissect_target-3.19.dev32}/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.dev30 → dissect_target-3.19.dev32}/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.dev30 → dissect_target-3.19.dev32}/dissect/target/tools/info.py

@@ -12,6 +12,7 @@ from dissect.target.exceptions import TargetError
 from dissect.target.helpers.record import TargetRecordDescriptor
 from dissect.target.tools.query import record_output
 from dissect.target.tools.utils import (
+    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     process_generic_arguments,
@@ -50,14 +51,14 @@ def main():
     )
     parser.add_argument("targets", metavar="TARGETS", nargs="*", help="Targets to display info from")
     parser.add_argument("--from-file", nargs="?", type=Path, help="file containing targets to load")
-    parser.add_argument("-d", "--delimiter", default=" ", action="store", metavar="','")
     parser.add_argument("-s", "--strings", action="store_true", help="print output as string")
     parser.add_argument("-r", "--record", action="store_true", help="print output as record")
     parser.add_argument("-j", "--json", action="store_true", help="output records as pretty json")
     parser.add_argument("-J", "--jsonlines", action="store_true", help="output records as one-line json")
+    parser.add_argument("-L", "--loader", action="store", default=None, help="select a specific loader (i.e. vmx, raw)")
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
+    args, rest = parser.parse_known_args()
 
     process_generic_arguments(args)
 
@@ -73,8 +74,10 @@ def main():
             targets = targets[:-1]
         args.targets = targets
 
+    targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
+
     try:
-        for i, target in enumerate(Target.open_all(args.targets)):
+        for i, target in enumerate(Target.open_all(targets)):
             try:
                 if args.jsonlines:
                     print(json.dumps(get_target_info(target), default=str))

{dissect_target-3.19.dev30 → dissect_target-3.19.dev32}/dissect/target/tools/yara.py

@@ -8,6 +8,7 @@ from dissect.target.exceptions import TargetError
 from dissect.target.plugins.filesystem.yara import HAS_YARA, YaraPlugin
 from dissect.target.tools.query import record_output
 from dissect.target.tools.utils import (
+    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     process_generic_arguments,
@@ -27,6 +28,7 @@ def main():
 
     parser.add_argument("targets", metavar="TARGETS", nargs="*", help="Targets to load")
     parser.add_argument("-s", "--strings", default=False, action="store_true", help="print output as string")
+    parser.add_argument("-L", "--loader", action="store", default=None, help="select a specific loader (i.e. vmx, raw)")
     parser.add_argument("--children", action="store_true", help="include children")
 
     for args, kwargs in getattr(YaraPlugin.yara, "__args__", []):
@@ -34,7 +36,7 @@ def main():
 
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
+    args, rest = parser.parse_known_args()
     process_generic_arguments(args)
 
     if not HAS_YARA:
@@ -45,8 +47,10 @@ def main():
         log.error("No targets provided")
         parser.exit(1)
 
+    targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
+
     try:
-        for target in Target.open_all(args.targets, args.children):
+        for target in Target.open_all(targets, args.children):
             rs = record_output(args.strings, False)
             for record in target.yara(args.rules, args.path, args.max_size, args.check):
                 rs.write(record)

{dissect_target-3.19.dev30 → dissect_target-3.19.dev32/dissect.target.egg-info}/PKG-INFO

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

@@ -583,6 +583,7 @@ tests/plugins/os/windows/regf/test_userassist.py
 tests/tools/__init__.py
 tests/tools/test_dump.py
 tests/tools/test_fs.py
+tests/tools/test_info.py
 tests/tools/test_mount.py
 tests/tools/test_query.py
 tests/tools/test_reg.py

{dissect_target-3.19.dev30 → dissect_target-3.19.dev32}/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(

dissect_target-3.19.dev32/tests/tools/test_info.py

@@ -0,0 +1,47 @@
+import json
+
+import pytest
+
+from dissect.target.tools.info import main as target_info
+
+
+@pytest.mark.parametrize(
+    "output_type, options",
+    [("json", ["-j"]), ("json", ["-J", "-L", "tar"]), ("record", ["-r", "-s"])],
+)
+def test_target_info(
+    capsys: pytest.CaptureFixture, monkeypatch: pytest.MonkeyPatch, output_type: str, options: list
+) -> None:
+    with monkeypatch.context() as m:
+        m.setattr("sys.argv", ["target-info", *options, "tests/_data/tools/info/image.tar"])
+
+        target_info()
+        stdout, stderr = capsys.readouterr()
+
+        assert "error" not in stderr
+
+        if output_type == "json":
+            assert json.loads(stdout) == {
+                "disks": [],
+                "volumes": [],
+                "children": [],
+                "hostname": "ubuntu",
+                "domain": None,
+                "ips": ["1.2.3.4"],
+                "os_family": "linux",
+                "os_version": "Ubuntu 22.04.4 LTS (Jammy Jellyfish)",
+                "architecture": None,
+                "language": [],
+                "timezone": "Europe/Amsterdam",
+                "install_date": "2024-07-02 12:00:56+00:00",
+                "last_activity": None,
+            }
+
+        elif output_type == "record":
+            assert (
+                stdout
+                == "<target/info hostname='ubuntu' domain=None last_activity=None install_date=2024-07-02 12:00:56+00:00 ips=[net.ipaddress('1.2.3.4')] os_family='linux' os_version='Ubuntu 22.04.4 LTS (Jammy Jellyfish)' architecture=None language=[] timezone='Europe/Amsterdam' disks=[] volumes=[] children=[]>\n"  # noqa: E501
+            )
+
+        else:
+            raise ValueError("unknown output_type %s", output_type)