dissect.target 3.21.dev15__tar.gz → 3.22.dev1__tar.gz

{dissect_target-3.21.dev15/dissect.target.egg-info → dissect_target-3.22.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.21.dev15
+Version: 3.22.dev1
 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.18.0
+Requires-Dist: flow.record~=3.19.0
 Requires-Dist: structlog
 Provides-Extra: full
 Requires-Dist: asn1crypto; extra == "full"
@@ -60,7 +60,7 @@ Requires-Dist: ruamel.yaml; extra == "full"
 Requires-Dist: tomli; python_version < "3.11" and extra == "full"
 Requires-Dist: zstandard; extra == "full"
 Provides-Extra: dev
-Requires-Dist: dissect.target[full,mqtt,yara]; extra == "dev"
+Requires-Dist: dissect.target[full,yara]; extra == "dev"
 Requires-Dist: dissect.archive[dev]<2.0.dev,>=1.0.dev; extra == "dev"
 Requires-Dist: dissect.btrfs[dev]<2.0.dev,>=1.0.dev; extra == "dev"
 Requires-Dist: dissect.cim[dev]<4.0.dev,>=3.0.dev; extra == "dev"
@@ -86,6 +86,7 @@ Requires-Dist: dissect.util<4.0.dev,>=3.0.dev; extra == "dev"
 Requires-Dist: dissect.vmfs[dev]<4.0.dev,>=3.0.dev; extra == "dev"
 Requires-Dist: dissect.volume[dev]<4.0.dev,>=3.0.dev; extra == "dev"
 Requires-Dist: dissect.xfs[dev]<4.0.dev,>=3.0.dev; extra == "dev"
+Requires-Dist: pexpect; extra == "dev"
 Provides-Extra: yara
 Requires-Dist: dissect.target[full]; extra == "yara"
 Requires-Dist: yara-python; extra == "yara"
@@ -98,6 +99,7 @@ Requires-Dist: carbon-black-cloud-sdk~=1.4.3; extra == "cb"
 Provides-Extra: mqtt
 Requires-Dist: dissect.target[full]; extra == "mqtt"
 Requires-Dist: paho-mqtt==1.6.1; extra == "mqtt"
+Dynamic: license-file
 
 # dissect.target
 

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/container.py

@@ -169,7 +169,7 @@ class Container(io.IOBase):
 
         Override this if you need to clean-up anything.
         """
-        raise NotImplementedError()
+        pass
 
 
 def register(module: str, class_name: str, internal: bool = True):

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/containers/fortifw.py

@@ -84,7 +84,7 @@ class FortiFirmwareFile(AlignedStream):
             if dec.unused_data:
                 self.trailer_offset = self.fh.seek(-len(dec.unused_data), io.SEEK_END)
                 self.trailer_data = self.fh.read()
-                log.info("Found trailer offset: %d, data: %r", self.trailer_offset, self.trailer_data)
+                log.debug("Found trailer offset: %d, data: %r", self.trailer_offset, self.trailer_data)
                 self.fh = RangeStream(self.fh, 0, self.trailer_offset)
 
             self.fh.seek(0)

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/exceptions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import errno
 import os
 import sys
 import traceback
@@ -76,22 +77,32 @@ class PluginNotFoundError(PluginError):
 class FileNotFoundError(FilesystemError, FileNotFoundError):
     """The requested path could not be found."""
 
+    errno = errno.ENOENT
+
 
 class IsADirectoryError(FilesystemError, IsADirectoryError):
     """The entry is a directory."""
 
+    errno = errno.EISDIR
+
 
 class NotADirectoryError(FilesystemError, NotADirectoryError):
     """The entry is not a directory."""
 
+    errno = errno.ENOTDIR
+
 
 class NotASymlinkError(FilesystemError):
     """The entry is not a symlink."""
 
+    errno = errno.EINVAL
+
 
 class SymlinkRecursionError(FilesystemError):
     """A symlink loop is detected for the entry."""
 
+    errno = errno.ELOOP
+
 
 class RegistryError(Error):
     """A registry error occurred."""

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/filesystems/dir.py

@@ -27,12 +27,7 @@ class DirectoryFilesystem(Filesystem):
     def _detect(fh: BinaryIO) -> bool:
         raise TypeError("Detect is not allowed on DirectoryFilesystem class")
 
-    def get(self, path: str) -> FilesystemEntry:
-        path = path.strip("/")
-
-        if not path:
-            return DirectoryFilesystemEntry(self, "/", self.base_path)
-
+    def _resolve_path(self, path: str) -> Path:
         if not self.case_sensitive:
             searchpath = self.base_path
 
@@ -48,6 +43,14 @@ class DirectoryFilesystem(Filesystem):
         else:
             entry = self.base_path.joinpath(path.strip("/"))
 
+        return entry
+
+    def get(self, path: str) -> FilesystemEntry:
+        if not (path := path.strip("/")):
+            return DirectoryFilesystemEntry(self, "/", self.base_path)
+
+        entry = self._resolve_path(path)
+
         try:
             entry.lstat()
             return DirectoryFilesystemEntry(self, path, entry)

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/filesystems/tar.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import stat
-import tarfile
+import tarfile as tf
 from typing import BinaryIO, Iterator, Optional
 
 from dissect.util.stream import BufferedStream
@@ -33,15 +33,20 @@ class TarFilesystem(Filesystem):
     def __init__(
         self,
         fh: BinaryIO,
-        base: Optional[str] = None,
-        tarinfo: Optional[tarfile.TarInfo] = None,
-        *args,
+        base: str | None = None,
+        *,
+        tarinfo: tf.TarInfo | None = None,
+        tarfile: tf.TarFile | None = None,
         **kwargs,
     ):
-        super().__init__(fh, *args, **kwargs)
-        fh.seek(0)
+        super().__init__(fh, **kwargs)
+
+        if tarfile:
+            self.tar = tarfile
+        else:
+            fh.seek(0)
+            self.tar = tf.open(mode="r", fileobj=fh, tarinfo=tarinfo)
 
-        self.tar = tarfile.open(mode="r", fileobj=fh, tarinfo=tarinfo)
         self.base = base or ""
 
         self._fs = VirtualFilesystem(alt_separator=self.alt_separator, case_sensitive=self.case_sensitive)
@@ -63,7 +68,7 @@ class TarFilesystem(Filesystem):
         fh = fsutil.open_decompress(fileobj=fh)
 
         fh.seek(257)
-        return fh.read(8) in (tarfile.GNU_MAGIC, tarfile.POSIX_MAGIC)
+        return fh.read(8) in (tf.GNU_MAGIC, tf.POSIX_MAGIC)
 
     def get(self, path: str, relentry: Optional[FilesystemEntry] = None) -> FilesystemEntry:
         """Returns a TarFilesystemEntry object corresponding to the given path."""
@@ -147,7 +152,7 @@ class TarFilesystemEntry(VirtualFile):
 
 
 class TarFilesystemDirectoryEntry(VirtualDirectory):
-    def __init__(self, fs: TarFilesystem, path: str, entry: tarfile.TarInfo):
+    def __init__(self, fs: TarFilesystem, path: str, entry: tf.TarInfo):
         super().__init__(fs, path)
         self.entry = entry
 

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/filesystems/zip.py

@@ -56,7 +56,7 @@ class ZipFilesystem(Filesystem):
             if not mname.startswith(self.base) or mname == ".":
                 continue
 
-            rel_name = fsutil.normpath(mname[len(self.base) :], alt_separator=self.alt_separator)
+            rel_name = self._resolve_path(mname)
             self._fs.map_file_entry(rel_name, ZipFilesystemEntry(self, rel_name, member))
 
     @staticmethod
@@ -64,6 +64,9 @@ class ZipFilesystem(Filesystem):
         """Detect a zip file on a given file-like object."""
         return zipfile.is_zipfile(fh)
 
+    def _resolve_path(self, path: str) -> str:
+        return fsutil.normpath(path[len(self.base) :], alt_separator=self.alt_separator)
+
     def get(self, path: str, relentry: FilesystemEntry = None) -> FilesystemEntry:
         """Returns a ZipFilesystemEntry object corresponding to the given path."""
         return self._fs.get(path, relentry=relentry)

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/helpers/cache.py

@@ -95,7 +95,7 @@ class Cache:
         target = args[0].target
 
         output = getattr(self.wrapper, "__output__", None)
-        if output not in ("record", "yield"):
+        if output not in ("record", "yield", "none"):
             # Cache property and default outputs on the target object itself
             func_cache = target._cache.setdefault(self.fname, {})
             key = (args[1:], frozenset(sorted(kwargs.items())))

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/helpers/compat/path_310.py

@@ -20,23 +20,15 @@ from __future__ import annotations
 import fnmatch
 import re
 from pathlib import Path, PurePath, _Accessor, _PosixFlavour
-from stat import S_ISBLK, S_ISCHR, S_ISFIFO, S_ISSOCK
-from typing import IO, TYPE_CHECKING, Any, Callable, Iterator, Optional
+from typing import IO, TYPE_CHECKING, Any, Callable, Iterator
 
 from dissect.target import filesystem
 from dissect.target.exceptions import FilesystemError, SymlinkRecursionError
-from dissect.target.helpers.compat.path_common import (
-    _DissectPathParents,
-    io_open,
-    isjunction,
-    realpath,
-    scandir,
-)
-from dissect.target.helpers.polypath import normalize
+from dissect.target.helpers import polypath
+from dissect.target.helpers.compat import path_common
 
 if TYPE_CHECKING:
     from dissect.target.filesystem import Filesystem, FilesystemEntry
-    from dissect.target.helpers.compat.path_common import _DissectScandirIterator
     from dissect.target.helpers.fsutil import stat_result
 
 
@@ -82,9 +74,9 @@ class _DissectAccessor(_Accessor):
         path: TargetPath,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -93,15 +85,15 @@ class _DissectAccessor(_Accessor):
         Note: in contrast to regular Python, the mode is binary by default. Text mode
         has to be explicitly specified. Buffering is also disabled by default.
         """
-        return io_open(path, mode, buffering, encoding, errors, newline)
+        return path_common.io_open(path, mode, buffering, encoding, errors, newline)
 
     @staticmethod
-    def listdir(path: TargetPath) -> Iterator[str]:
+    def listdir(path: TargetPath) -> list[str]:
         return path.get().listdir()
 
     @staticmethod
-    def scandir(path: TargetPath) -> _DissectScandirIterator:
-        return scandir(path)
+    def scandir(path: TargetPath) -> path_common._DissectScandirIterator:
+        return path_common.scandir(path)
 
     @staticmethod
     def chmod(path: TargetPath, mode: int, *, follow_symlinks: bool = True) -> None:
@@ -163,10 +155,10 @@ class _DissectAccessor(_Accessor):
     def expanduser(path: str) -> str:
         raise NotImplementedError("TargetPath.expanduser() is unsupported")
 
-    realpath = staticmethod(realpath)
+    realpath = staticmethod(path_common.realpath)
 
     # NOTE: Forward compatibility with CPython >= 3.12
-    isjunction = staticmethod(isjunction)
+    isjunction = staticmethod(path_common.isjunction)
 
 
 _dissect_accessor = _DissectAccessor()
@@ -193,7 +185,7 @@ class PureDissectPath(PurePath):
         path_args = []
         for arg in args[1:]:
             if isinstance(arg, str):
-                arg = normalize(arg, alt_separator=alt_separator)
+                arg = polypath.normalize(arg, alt_separator=alt_separator)
             path_args.append(arg)
 
         self = super()._from_parts(path_args)
@@ -247,8 +239,8 @@ class PureDissectPath(PurePath):
         return result
 
     @property
-    def parents(self) -> _DissectPathParents:
-        return _DissectPathParents(self)
+    def parents(self) -> path_common._DissectPathParents:
+        return path_common._DissectPathParents(self)
 
 
 class TargetPath(Path, PureDissectPath):
@@ -382,9 +374,9 @@ class TargetPath(Path, PureDissectPath):
         self,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -402,7 +394,7 @@ class TargetPath(Path, PureDissectPath):
         raise NotImplementedError("TargetPath.write_bytes() is unsupported")
 
     def write_text(
-        self, data: str, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+        self, data: str, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """
         Open the file in text mode, write to it, and close the file.
@@ -417,45 +409,6 @@ class TargetPath(Path, PureDissectPath):
         obj = self._from_parts((self._fs, path))
         return obj
 
-    def exists(self) -> bool:
-        """
-        Whether this path exists.
-        """
-        try:
-            # .exists() must resolve possible symlinks
-            self.get().stat()
-            return True
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_dir(self) -> bool:
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return self.get().is_dir()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_file(self) -> bool:
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return self.get().is_file()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_symlink(self) -> bool:
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return self.get().is_symlink()
-        except (FilesystemError, ValueError):
-            return False
-
     # NOTE: Forward compatibility with CPython >= 3.12
     def is_junction(self) -> bool:
         """
@@ -463,42 +416,6 @@ class TargetPath(Path, PureDissectPath):
         """
         return self._accessor.isjunction(self)
 
-    def is_block_device(self) -> bool:
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_char_device(self) -> bool:
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_fifo(self) -> bool:
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_socket(self) -> bool:
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
     def expanduser(self) -> TargetPath:
         """Return a new path with expanded ~ and ~user constructs
         (as returned by os.path.expanduser)

{dissect_target-3.21.dev15 → dissect_target-3.22.dev1}/dissect/target/helpers/compat/path_311.py

@@ -17,34 +17,21 @@ Commit hash we're in sync with: 846a23d
 Notes:
     - CPython 3.11 ditched the _Accessor class, so we override the methods that should use it
 """
+
 from __future__ import annotations
 
 import fnmatch
 import re
 from pathlib import Path, PurePath, _PosixFlavour
-from stat import S_ISBLK, S_ISCHR, S_ISFIFO, S_ISSOCK
-from typing import IO, TYPE_CHECKING, Any, Callable, Iterator, Optional
+from typing import IO, TYPE_CHECKING, Any, Callable, Iterator
 
 from dissect.target import filesystem
-from dissect.target.exceptions import (
-    FileNotFoundError,
-    FilesystemError,
-    NotADirectoryError,
-    NotASymlinkError,
-    SymlinkRecursionError,
-)
-from dissect.target.helpers.compat.path_common import (
-    _DissectPathParents,
-    io_open,
-    isjunction,
-    realpath,
-    scandir,
-)
-from dissect.target.helpers.polypath import normalize
+from dissect.target.exceptions import FilesystemError, SymlinkRecursionError
+from dissect.target.helpers import polypath
+from dissect.target.helpers.compat import path_common
 
 if TYPE_CHECKING:
     from dissect.target.filesystem import Filesystem, FilesystemEntry
-    from dissect.target.helpers.compat.path_common import _DissectScandirIterator
     from dissect.target.helpers.fsutil import stat_result
 
 
@@ -101,7 +88,7 @@ class PureDissectPath(PurePath):
         path_args = []
         for arg in args[1:]:
             if isinstance(arg, str):
-                arg = normalize(arg, alt_separator=alt_separator)
+                arg = polypath.normalize(arg, alt_separator=alt_separator)
             path_args.append(arg)
 
         self = super()._from_parts(path_args)
@@ -155,8 +142,8 @@ class PureDissectPath(PurePath):
         return result
 
     @property
-    def parents(self) -> _DissectPathParents:
-        return _DissectPathParents(self)
+    def parents(self) -> path_common._DissectPathParents:
+        return path_common._DissectPathParents(self)
 
 
 class TargetPath(Path, PureDissectPath):
@@ -193,7 +180,7 @@ class TargetPath(Path, PureDissectPath):
         """Iterate over the files in this directory.  Does not yield any
         result for the special paths '.' and '..'.
         """
-        for entry in scandir(self):
+        for entry in path_common.scandir(self):
             if entry.name in {".", ".."}:
                 # Yielding a path object for these makes little sense
                 continue
@@ -201,8 +188,8 @@ class TargetPath(Path, PureDissectPath):
             child_path._entry = entry
             yield child_path
 
-    def _scandir(self) -> _DissectScandirIterator:
-        return scandir(self)
+    def _scandir(self) -> path_common._DissectScandirIterator:
+        return path_common.scandir(self)
 
     # NOTE: Forward compatibility with CPython >= 3.12
     def walk(
@@ -267,7 +254,7 @@ class TargetPath(Path, PureDissectPath):
         normalizing it.
         """
 
-        s = realpath(self, strict=strict)
+        s = path_common.realpath(self, strict=strict)
         p = self._from_parts((self._fs, s))
 
         # In non-strict mode, realpath() doesn't raise on symlink loops.
@@ -306,9 +293,9 @@ class TargetPath(Path, PureDissectPath):
         self,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -317,7 +304,7 @@ class TargetPath(Path, PureDissectPath):
         Note: in contrast to regular Python, the mode is binary by default. Text mode
         has to be explicitly specified. Buffering is also disabled by default.
         """
-        return io_open(self, mode, buffering, encoding, errors, newline)
+        return path_common.io_open(self, mode, buffering, encoding, errors, newline)
 
     def write_bytes(self, data: bytes) -> int:
         """
@@ -326,7 +313,7 @@ class TargetPath(Path, PureDissectPath):
         raise NotImplementedError("TargetPath.write_bytes() is unsupported")
 
     def write_text(
-        self, data: str, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+        self, data: str, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """
         Open the file in text mode, write to it, and close the file.
@@ -430,36 +417,6 @@ class TargetPath(Path, PureDissectPath):
         """
         raise NotImplementedError("TargetPath.link_to() is unsupported")
 
-    def exists(self) -> bool:
-        """
-        Whether this path exists.
-        """
-        try:
-            # .exists() must resolve possible symlinks
-            self.get().stat()
-            return True
-        except (FileNotFoundError, NotADirectoryError, NotASymlinkError, SymlinkRecursionError, ValueError):
-            return False
-
-    def is_dir(self) -> bool:
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return self.get().is_dir()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_file(self) -> bool:
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return self.get().is_file()
-        except (FilesystemError, ValueError):
-            return False
-
     def is_mount(self) -> bool:
         """
         Check if this path is a POSIX mount point
@@ -480,57 +437,12 @@ class TargetPath(Path, PureDissectPath):
         parent_ino = self.parent.stat().st_ino
         return ino == parent_ino
 
-    def is_symlink(self) -> bool:
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return self.get().is_symlink()
-        except (FilesystemError, ValueError):
-            return False
-
     # NOTE: Forward compatibility with CPython >= 3.12
     def is_junction(self) -> bool:
         """
         Whether this path is a junction.
         """
-        return isjunction(self)
-
-    def is_block_device(self) -> bool:
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_char_device(self) -> bool:
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_fifo(self) -> bool:
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_socket(self) -> bool:
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
+        return path_common.isjunction(self)
 
     def expanduser(self) -> TargetPath:
         """Return a new path with expanded ~ and ~user constructs