dissect.target 3.19.dev32__tar.gz → 3.19.dev34__tar.gz

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

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

@@ -1,27 +1,35 @@
+from __future__ import annotations
+
 import ast
 import importlib.machinery
 import importlib.util
 import logging
 from pathlib import Path
 from types import ModuleType
-from typing import Optional, Union
 
 log = logging.getLogger(__name__)
 
 CONFIG_NAME = ".targetcfg.py"
 
 
-def load(path: Optional[Union[Path, str]]) -> ModuleType:
+def load(paths: list[Path | str] | Path | str | None) -> ModuleType:
+    """Attempt to load one configuration from the provided path(s)."""
+
+    if isinstance(paths, Path) or isinstance(paths, str):
+        paths = [paths]
+
     config_spec = importlib.machinery.ModuleSpec("config", None)
     config = importlib.util.module_from_spec(config_spec)
-    config_file = _find_config_file(path)
+    config_file = _find_config_file(paths)
+
     if config_file:
         config_values = _parse_ast(config_file.read_bytes())
         config.__dict__.update(config_values)
+
     return config
 
 
-def _parse_ast(code: str) -> dict[str, Union[str, int]]:
+def _parse_ast(code: str) -> dict[str, str | int]:
     # Only allow basic value assignments for backwards compatibility
     obj = {}
 
@@ -49,15 +57,19 @@ def _parse_ast(code: str) -> dict[str, Union[str, int]]:
     return obj
 
 
-def _find_config_file(path: Optional[Union[Path, str]]) -> Optional[Path]:
-    """Find a config file anywhere in the given path and return it.
+def _find_config_file(paths: list[Path | str] | None) -> Path | None:
+    """Find a config file anywhere in the given path(s) and return it.
 
     This algorithm allows parts of the path to not exist or the last part to be a filename.
     It also does not look in the root directory ('/') for config files.
     """
 
+    if not paths:
+        return
+
     config_file = None
-    if path:
+
+    for path in paths:
         path = Path(path)
         cur_path = path.absolute()
 
@@ -69,4 +81,7 @@ def _find_config_file(path: Optional[Union[Path, str]]) -> Optional[Path]:
                 config_file = cur_config
             cur_path = cur_path.parent
 
+        if config_file:
+            break
+
     return config_file

{dissect_target-3.19.dev32 → dissect_target-3.19.dev34}/dissect/target/helpers/loaderutil.py

@@ -5,7 +5,7 @@ import re
 import urllib
 from os import PathLike
 from pathlib import Path
-from typing import TYPE_CHECKING, BinaryIO, Optional, Union
+from typing import TYPE_CHECKING, BinaryIO
 
 from dissect.target.exceptions import FileNotFoundError
 from dissect.target.filesystem import Filesystem
@@ -42,12 +42,31 @@ def add_virtual_ntfs_filesystem(
     fh_sds = _try_open(fs, sds_path)
 
     if any([fh_boot, fh_mft]):
-        ntfs = NtfsFilesystem(boot=fh_boot, mft=fh_mft, usnjrnl=fh_usnjrnl, sds=fh_sds)
-        target.filesystems.add(ntfs)
-        fs.ntfs = ntfs.ntfs
+        ntfs = None
 
-
-def _try_open(fs: Filesystem, path: str) -> BinaryIO:
+        try:
+            ntfs = NtfsFilesystem(boot=fh_boot, mft=fh_mft, usnjrnl=fh_usnjrnl, sds=fh_sds)
+        except Exception as e:
+            if fh_boot:
+                log.warning("Failed to load NTFS filesystem from %s, retrying without $Boot file", fs)
+                log.debug("", exc_info=e)
+
+                try:
+                    # Try once more without the $Boot file
+                    ntfs = NtfsFilesystem(mft=fh_mft, usnjrnl=fh_usnjrnl, sds=fh_sds)
+                except Exception:
+                    log.warning("Failed to load NTFS filesystem from %s without $Boot file, skipping", fs)
+                    return
+
+        # Only add it if we have a valid NTFS with an MFT
+        if ntfs and ntfs.ntfs.mft:
+            target.filesystems.add(ntfs)
+            fs.ntfs = ntfs.ntfs
+        else:
+            log.warning("Opened NTFS filesystem from %s but could not find $MFT, skipping", fs)
+
+
+def _try_open(fs: Filesystem, path: str) -> BinaryIO | None:
     paths = [path] if not isinstance(path, list) else path
 
     for path in paths:
@@ -61,7 +80,7 @@ def _try_open(fs: Filesystem, path: str) -> BinaryIO:
             pass
 
 
-def extract_path_info(path: Union[str, Path]) -> tuple[Path, Optional[urllib.parse.ParseResult]]:
+def extract_path_info(path: str | Path) -> tuple[Path, urllib.parse.ParseResult | None]:
     """
     Extracts a ParseResult from a path if it has
     a scheme and adjusts the path if necessary.

{dissect_target-3.19.dev32 → dissect_target-3.19.dev34}/dissect/target/target.py

@@ -87,9 +87,10 @@ class Target:
         self._applied = False
 
         try:
-            self._config = config.load(self.path)
+            self._config = config.load([self.path, os.getcwd()])
         except Exception as e:
-            self.log.debug("Error loading config file", exc_info=e)
+            self.log.warning("Error loading config file: %s", self.path)
+            self.log.debug("", exc_info=e)
             self._config = config.load(None)  # This loads an empty config.
 
         # Fill the disks and/or volumes and/or filesystems and apply() will

{dissect_target-3.19.dev32 → dissect_target-3.19.dev34}/dissect/target/tools/shell.py

@@ -58,6 +58,7 @@ try:
 except ImportError:
     # Readline is not available on Windows
     log.warning("Readline module is not available")
+    readline = None
 
 # ['mode', 'addr', 'dev', 'nlink', 'uid', 'gid', 'size', 'atime', 'mtime', 'ctime']
 STAT_TEMPLATE = """  File: {path} {symlink}
@@ -111,12 +112,43 @@ class TargetCmd(cmd.Cmd):
 
     CMD_PREFIX = "cmd_"
 
+    DEFAULT_HISTFILE = "~/.dissect_history"
+    DEFAULT_HISTFILESIZE = 10_000
+    DEFAULT_HISTDIR = None
+    DEFAULT_HISTDIRFMT = ".dissect_history_{uid}_{target}"
+
     def __init__(self, target: Target):
         cmd.Cmd.__init__(self)
         self.target = target
         self.debug = False
         self.identchars += "."
 
+        self.histfilesize = getattr(target._config, "HISTFILESIZE", self.DEFAULT_HISTFILESIZE)
+        self.histdir = getattr(target._config, "HISTDIR", self.DEFAULT_HISTDIR)
+
+        if self.histdir:
+            self.histdirfmt = getattr(target._config, "HISTDIRFMT", self.DEFAULT_HISTDIRFMT)
+            self.histfile = pathlib.Path(self.histdir).resolve() / pathlib.Path(
+                self.histdirfmt.format(uid=os.getuid(), target=target.name)
+            )
+        else:
+            self.histfile = pathlib.Path(getattr(target._config, "HISTFILE", self.DEFAULT_HISTFILE)).expanduser()
+
+    def preloop(self) -> None:
+        if readline and self.histfile.exists():
+            try:
+                readline.read_history_file(self.histfile)
+            except Exception as e:
+                log.debug("Error reading history file: %s", e)
+
+    def postloop(self) -> None:
+        if readline:
+            readline.set_history_length(self.histfilesize)
+            try:
+                readline.write_history_file(self.histfile)
+            except Exception as e:
+                log.debug("Error writing history file: %s", e)
+
     def __getattr__(self, attr: str) -> Any:
         if attr.startswith("help_"):
             _, _, command = attr.partition("_")
@@ -1241,10 +1273,11 @@ def run_cli(cli: cmd.Cmd) -> None:
             # Print an empty newline on exit
             print()
             return
+
         except KeyboardInterrupt:
             # Add a line when pressing ctrl+c, so the next one starts at a new line
             print()
-            pass
+
         except Exception as e:
             if cli.debug:
                 log.exception(e)
@@ -1252,7 +1285,6 @@ def run_cli(cli: cmd.Cmd) -> None:
                 log.info(e)
                 print(f"*** Unhandled error: {e}")
                 print("If you wish to see the full debug trace, enable debug mode.")
-            pass
 
 
 @catch_sigpipe

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev32
+Version: 3.19.dev34
 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.dev34/tests/helpers/test_loaderutil.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import urllib
+from pathlib import Path
+from typing import TYPE_CHECKING
+from unittest.mock import Mock, patch
+
+import pytest
+
+from dissect.target.filesystem import VirtualFilesystem
+from dissect.target.filesystems.dir import DirectoryFilesystem
+from dissect.target.helpers.fsutil import TargetPath
+from dissect.target.helpers.loaderutil import (
+    add_virtual_ntfs_filesystem,
+    extract_path_info,
+)
+
+if TYPE_CHECKING:
+    from dissect.target.target import Target
+
+
+@pytest.mark.parametrize(
+    "path, expected",
+    [
+        # None objects fall through (BC)
+        (None, (None, None)),
+        # Path objects fall through (BC/DRY)
+        (Path("path"), (Path("path"), None)),
+        (TargetPath(DirectoryFilesystem("/")), (TargetPath(DirectoryFilesystem("/")), None)),
+        # Strings get upgraded to Paths
+        ("/path/to/file", (Path("/path/to/file"), None)),
+        # URIs get converted to Path extracted from path part and a ParseResult
+        (
+            "tar:///folder/file.tar.gz",
+            (Path("/folder/file.tar.gz"), urllib.parse.urlparse("tar:///folder/file.tar.gz")),
+        ),
+        (
+            "tar://relative/folder/file.tar.gz",
+            (Path("relative/folder/file.tar.gz"), urllib.parse.urlparse("tar://relative/folder/file.tar.gz")),
+        ),
+        ("tar://~/file.tar.gz", (Path("~/file.tar.gz").expanduser(), urllib.parse.urlparse("tar://~/file.tar.gz"))),
+        # But not if the URI has a faux scheme
+        ("C:\\path\\to\\file", (Path("C:\\path\\to\\file"), None)),
+    ],
+)
+def test_extract_path_info(
+    path: Path | str, expected: tuple[Path | None, urllib.parse.ParseResult[str] | None]
+) -> None:
+    assert extract_path_info(path) == expected
+
+
+@pytest.mark.parametrize(
+    "boot, mft, expected_logs",
+    [
+        (None, None, []),
+        (
+            None,
+            False,
+            [
+                "Opened NTFS filesystem from <VirtualFilesystem> but could not find $MFT, skipping",
+            ],
+        ),
+        (None, True, []),
+        (
+            False,
+            None,
+            [
+                "Failed to load NTFS filesystem from <VirtualFilesystem>, retrying without $Boot file",
+                "Opened NTFS filesystem from <VirtualFilesystem> but could not find $MFT, skipping",
+            ],
+        ),
+        (
+            False,
+            False,
+            [
+                "Failed to load NTFS filesystem from <VirtualFilesystem>, retrying without $Boot file",
+                "Failed to load NTFS filesystem from <VirtualFilesystem> without $Boot file, skipping",
+            ],
+        ),
+        (
+            False,
+            True,
+            [
+                "Failed to load NTFS filesystem from <VirtualFilesystem>, retrying without $Boot file",
+            ],
+        ),
+        (
+            True,
+            None,
+            [
+                "Opened NTFS filesystem from <VirtualFilesystem> but could not find $MFT, skipping",
+            ],
+        ),
+        (
+            True,
+            False,
+            [
+                "Failed to load NTFS filesystem from <VirtualFilesystem>, retrying without $Boot file",
+                "Failed to load NTFS filesystem from <VirtualFilesystem> without $Boot file, skipping",
+            ],
+        ),
+        (True, True, []),
+    ],
+)
+def test_virtual_ntfs_resiliency(
+    boot: bool | None,
+    mft: bool | None,
+    expected_logs: list[str],
+    target_default: Target,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    sentinels = {
+        None: None,
+        False: Mock(),
+        True: Mock(),
+    }
+
+    def _try_open(fs, path):
+        state = None
+        if path == "$Boot":
+            state = boot
+        elif path == "$MFT":
+            state = mft
+        return sentinels[state]
+
+    def NtfsFilesystem(boot=None, mft=None, **kwargs):
+        if boot is sentinels[False] or mft is sentinels[False]:
+            raise Exception("Oopsiewoopsie")
+
+        fake_ntfs = Mock()
+        fake_ntfs.ntfs.mft = None
+
+        if mft is sentinels[True]:
+            fake_ntfs.ntfs.mft = Mock()
+
+        return fake_ntfs
+
+    vfs = VirtualFilesystem()
+    with patch("dissect.target.helpers.loaderutil._try_open", new=_try_open), patch(
+        "dissect.target.helpers.loaderutil.NtfsFilesystem", new=NtfsFilesystem
+    ):
+        add_virtual_ntfs_filesystem(target_default, vfs)
+
+    assert caplog.messages == expected_logs
+    assert hasattr(vfs, "ntfs") == (True if mft else False)

dissect_target-3.19.dev32/tests/helpers/test_loaderutil.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import urllib
-from pathlib import Path
-from typing import Optional
-
-import pytest
-
-from dissect.target.filesystems.dir import DirectoryFilesystem
-from dissect.target.helpers.fsutil import TargetPath
-from dissect.target.helpers.loaderutil import extract_path_info
-
-
-@pytest.mark.parametrize(
-    "path, expected",
-    [
-        # None objects fall through (BC)
-        (None, (None, None)),
-        # Path objects fall through (BC/DRY)
-        (Path("path"), (Path("path"), None)),
-        (TargetPath(DirectoryFilesystem("/")), (TargetPath(DirectoryFilesystem("/")), None)),
-        # Strings get upgraded to Paths
-        ("/path/to/file", (Path("/path/to/file"), None)),
-        # URIs get converted to Path extracted from path part and a ParseResult
-        (
-            "tar:///folder/file.tar.gz",
-            (Path("/folder/file.tar.gz"), urllib.parse.urlparse("tar:///folder/file.tar.gz")),
-        ),
-        (
-            "tar://relative/folder/file.tar.gz",
-            (Path("relative/folder/file.tar.gz"), urllib.parse.urlparse("tar://relative/folder/file.tar.gz")),
-        ),
-        ("tar://~/file.tar.gz", (Path("~/file.tar.gz").expanduser(), urllib.parse.urlparse("tar://~/file.tar.gz"))),
-        # But not if the URI has a faux scheme
-        ("C:\\path\\to\\file", (Path("C:\\path\\to\\file"), None)),
-    ],
-)
-def test_extract_path_info(
-    path: Path | str, expected: tuple[Optional[Path], Optional[urllib.parse.ParseResult[str]]]
-) -> None:
-    assert extract_path_info(path) == expected