dissect.target 3.19.dev46__py3-none-any.whl → 3.19.dev48__py3-none-any.whl

dissect/target/filesystem.py

@@ -228,10 +228,9 @@ class Filesystem:
         topdown: bool = True,
         onerror: Optional[Callable] = None,
         followlinks: bool = False,
-    ) -> Iterator[str]:
-        """Walk a directory pointed to by ``path``, returning the string representation of both files and directories.
-
-        It walks across all the files inside ``path`` recursively.
+    ) -> Iterator[tuple[str, list[str], list[str]]]:
+        """Recursively walk a directory pointed to by ``path``, returning the string representation of both files
+        and directories.
 
         Args:
             path: The path to walk on the filesystem.
@@ -250,10 +249,9 @@ class Filesystem:
         topdown: bool = True,
         onerror: Optional[Callable] = None,
         followlinks: bool = False,
-    ) -> Iterator[FilesystemEntry]:
-        """Walk a directory pointed to by ``path``, returning FilesystemEntry's of both files and directories.
-
-        It walks across all the files inside ``path`` recursively.
+    ) -> Iterator[tuple[list[FilesystemEntry], list[FilesystemEntry], list[FilesystemEntry]]]:
+        """Recursively walk a directory pointed to by ``path``, returning :class:`FilesystemEntry` of files
+        and directories.
 
         Args:
             path: The path to walk on the filesystem.
@@ -266,6 +264,19 @@ class Filesystem:
         """
         return self.get(path).walk_ext(topdown, onerror, followlinks)
 
+    def recurse(self, path: str) -> Iterator[FilesystemEntry]:
+        """Recursively walk a directory and yield contents as :class:`FilesystemEntry`.
+
+        Does not follow symbolic links.
+
+        Args:
+            path: The path to recursively walk on the target filesystem.
+
+        Returns:
+            An iterator of :class:`FilesystemEntry`.
+        """
+        return self.get(path).recurse()
+
     def glob(self, pattern: str) -> Iterator[str]:
         """Iterate over the directory part of ``pattern``, returning entries matching ``pattern`` as strings.
 
@@ -578,10 +589,9 @@ class FilesystemEntry:
         topdown: bool = True,
         onerror: Optional[Callable] = None,
         followlinks: bool = False,
-    ) -> Iterator[str]:
-        """Walk a directory and list its contents as strings.
-
-        It walks across all the files inside the entry recursively.
+    ) -> Iterator[tuple[str, list[str], list[str]]]:
+        """Recursively walk a directory and yield its contents as strings split in a tuple
+        of lists of files, directories and symlinks.
 
         These contents include::
           - files
@@ -603,15 +613,9 @@ class FilesystemEntry:
         topdown: bool = True,
         onerror: Optional[Callable] = None,
         followlinks: bool = False,
-    ) -> Iterator[FilesystemEntry]:
-        """Walk a directory and show its contents as :class:`FilesystemEntry`.
-
-        It walks across all the files inside the entry recursively.
-
-        These contents include::
-          - files
-          - directories
-          - symboliclinks
+    ) -> Iterator[tuple[list[FilesystemEntry], list[FilesystemEntry], list[FilesystemEntry]]]:
+        """Recursively walk a directory and yield its contents as :class:`FilesystemEntry` split in a tuple of
+        lists of files, directories and symlinks.
 
         Args:
             topdown: ``True`` puts this entry at the top of the list, ``False`` puts this entry at the bottom.
@@ -619,10 +623,20 @@ class FilesystemEntry:
             followlinks: ``True`` if we want to follow any symbolic link
 
         Returns:
-            An iterator of :class:`FilesystemEntry`.
+            An iterator of tuples :class:`FilesystemEntry`.
         """
         yield from fsutil.walk_ext(self, topdown, onerror, followlinks)
 
+    def recurse(self) -> Iterator[FilesystemEntry]:
+        """Recursively walk a directory and yield its contents as :class:`FilesystemEntry`.
+
+        Does not follow symbolic links.
+
+        Returns:
+            An iterator of :class:`FilesystemEntry`.
+        """
+        yield from fsutil.recurse(self)
+
     def glob(self, pattern: str) -> Iterator[str]:
         """Iterate over this directory part of ``patern``, returning entries matching ``pattern`` as strings.
 
@@ -739,7 +753,7 @@ class FilesystemEntry:
         """
         log.debug("%r::readlink_ext()", self)
         # Default behavior, resolve link own filesystem.
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Determine the stat information of this entry.
@@ -1453,10 +1467,15 @@ class LayerFilesystem(Filesystem):
         """Get a :class:`FilesystemEntry` relative to a specific entry."""
         parts = path.split("/")
 
-        for part in parts:
+        for i, part in enumerate(parts):
             if entry.is_symlink():
                 # Resolve using the RootFilesystem instead of the entry's Filesystem
-                entry = fsutil.resolve_link(fs=self, entry=entry)
+                entry = fsutil.resolve_link(
+                    self,
+                    entry.readlink(),
+                    "/".join(parts[:i]),
+                    alt_separator=entry.fs.alt_separator,
+                )
             entry = entry.get(part)
 
         return entry

dissect/target/filesystems/itunes.py

@@ -94,7 +94,7 @@ class ITunesFilesystemEntry(VirtualFile):
     def readlink_ext(self) -> FilesystemEntry:
         """Read the link if this entry is a symlink. Returns a filesystem entry."""
         # Can't use the one in VirtualFile as it overrides the FilesystemEntry
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Return the stat information of this entry."""

dissect/target/filesystems/tar.py

@@ -121,7 +121,7 @@ class TarFilesystemEntry(VirtualFile):
     def readlink_ext(self) -> FilesystemEntry:
         """Read the link if this entry is a symlink. Returns a filesystem entry."""
         # Can't use the one in VirtualFile as it overrides the FilesystemEntry
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Return the stat information of this entry."""

dissect/target/helpers/fsutil.py

@@ -96,6 +96,7 @@ __all__ = [
     "TargetPath",
     "walk_ext",
     "walk",
+    "recurse",
 ]
 
 
@@ -291,6 +292,20 @@ def walk_ext(path_entry, topdown=True, onerror=None, followlinks=False):
         yield [path_entry], dirs, files
 
 
+def recurse(path_entry: filesystem.FilesystemEntry) -> Iterator[filesystem.FilesystemEntry]:
+    """Recursively walk the given :class:`FilesystemEntry`, yields :class:`FilesystemEntry` instances."""
+    yield path_entry
+
+    if not path_entry.is_dir():
+        return
+
+    for child_entry in path_entry.scandir():
+        if child_entry.is_dir() and not child_entry.is_symlink():
+            yield from recurse(child_entry)
+        else:
+            yield child_entry
+
+
 def glob_split(pattern: str, alt_separator: str = "") -> tuple[str, str]:
     """Split a pattern on path part boundaries on the first path part with a glob pattern.
 
@@ -425,15 +440,20 @@ def has_glob_magic(s) -> bool:
 
 
 def resolve_link(
-    fs: filesystem.Filesystem, entry: filesystem.FilesystemEntry, previous_links: set[str] = None
+    fs: filesystem.Filesystem,
+    link: str,
+    path: str,
+    *,
+    alt_separator: str = "",
+    previous_links: set[str] | None = None,
 ) -> filesystem.FilesystemEntry:
     """Resolves a symlink to its actual path.
 
     It stops resolving once it detects an infinite recursion loop.
     """
 
-    link = normalize(entry.readlink(), alt_separator=entry.fs.alt_separator)
-    path = normalize(entry.path, alt_separator=entry.fs.alt_separator)
+    link = normalize(link, alt_separator=alt_separator)
+    path = normalize(path, alt_separator=alt_separator)
 
     # Create hash for entry based on path and link
     link_id = f"{path}{link}"
@@ -456,7 +476,13 @@ def resolve_link(
     entry = fs.get(link)
 
     if entry.is_symlink():
-        entry = resolve_link(fs, entry, previous_links)
+        entry = resolve_link(
+            fs,
+            entry.readlink(),
+            link,
+            alt_separator=entry.fs.alt_separator,
+            previous_links=previous_links,
+        )
 
     return entry
 

dissect/target/plugins/filesystem/unix/capability.py

@@ -1,20 +1,20 @@
-import struct
 from enum import IntEnum
 from io import BytesIO
+from typing import Iterator
 
-from dissect.target.exceptions import FileNotFoundError, UnsupportedPluginError
+from dissect.target.exceptions import UnsupportedPluginError
 from dissect.target.helpers.record import TargetRecordDescriptor
 from dissect.target.plugin import Plugin, export
-from dissect.target.plugins.filesystem.walkfs import generate_record
 
 CapabilityRecord = TargetRecordDescriptor(
     "filesystem/unix/capability",
     [
-        ("record", "record"),
+        ("datetime", "ts_mtime"),
+        ("path", "path"),
         ("string[]", "permitted"),
         ("string[]", "inheritable"),
         ("boolean", "effective"),
-        ("uint32", "rootid"),
+        ("uint32", "root_id"),
     ],
 )
 
@@ -82,88 +82,103 @@ class CapabilityPlugin(Plugin):
     """Plugin to yield files with capabilites set."""
 
     def check_compatible(self) -> None:
-        if not self.target.has_function("walkfs") or self.target.os == "windows":
-            raise UnsupportedPluginError("Unsupported plugin")
+        if not self.target.has_function("walkfs"):
+            raise UnsupportedPluginError("Need walkfs plugin")
+
+        if not any(fs.__type__ in ("extfs", "xfs") for fs in self.target.filesystems):
+            raise UnsupportedPluginError("Capability plugin only works on EXT and XFS filesystems")
 
     @export(record=CapabilityRecord)
-    def capability_binaries(self):
-        """Find all files that have capabilities set."""
-        for path_entries, _, files in self.target.fs.walk_ext("/"):
-            entries = [path_entries[-1]] + files
-            for entry in entries:
-                path = self.target.fs.path(entry.path)
-                try:
-                    record = generate_record(self.target, path)
-                except FileNotFoundError:
-                    continue
+    def capability_binaries(self) -> Iterator[CapabilityRecord]:
+        """Find all files that have capabilities set on files.
+
+        Resources:
+            - https://github.com/torvalds/linux/blob/master/include/uapi/linux/capability.h
+        """
+
+        for entry in self.target.fs.recurse("/"):
+            if not entry.is_file() or entry.is_symlink():
+                continue
+
+            try:
+                attrs = [attr for attr in entry.lattr() if attr.name == "security.capability"]
+            except Exception as e:
+                self.target.log.warning("Failed to get attrs for entry %s", entry)
+                self.target.log.debug("", exc_info=e)
+                continue
+
+            for attr in attrs:
                 try:
-                    attrs = path.get().lattr()
-                except TypeError:
-                    # Virtual(File|Directory|Symlink) instances don't have a functional lattr()
-                    continue
-                except Exception:
-                    self.target.log.exception("Failed to get attrs for entry %s", entry)
-                    continue
-
-                for attr in attrs:
-                    if attr.name != "security.capability":
-                        continue
-
-                    buf = BytesIO(attr.value)
-
-                    # Reference: https://github.com/torvalds/linux/blob/master/include/uapi/linux/capability.h
-                    # The struct is small enough we can just use struct
-                    magic_etc = struct.unpack("<I", buf.read(4))[0]
-                    cap_revision = magic_etc & VFS_CAP_REVISION_MASK
-
-                    permitted_caps = []
-                    inheritable_caps = []
-                    rootid = None
-
-                    if cap_revision == VFS_CAP_REVISION_1:
-                        num_caps = VFS_CAP_U32_1
-                        data_len = (1 + 2 * VFS_CAP_U32_1) * 4
-                    elif cap_revision == VFS_CAP_REVISION_2:
-                        num_caps = VFS_CAP_U32_2
-                        data_len = (1 + 2 * VFS_CAP_U32_2) * 4
-                    elif cap_revision == VFS_CAP_REVISION_3:
-                        num_caps = VFS_CAP_U32_3
-                        data_len = (2 + 2 * VFS_CAP_U32_2) * 4
-                    else:
-                        self.target.log.error("Unexpected capability revision: %s", entry)
-                        continue
-
-                    if data_len != len(attr.value):
-                        self.target.log.error("Unexpected capability length: %s", entry)
-                        continue
-
-                    for _ in range(num_caps):
-                        permitted_val, inheritable_val = struct.unpack("<2I", buf.read(8))
-                        permitted_caps.append(permitted_val)
-                        inheritable_caps.append(inheritable_val)
-
-                    if cap_revision == VFS_CAP_REVISION_3:
-                        rootid = struct.unpack("<I", buf.read(4))[0]
-
-                    permitted = []
-                    inheritable = []
-
-                    for capability in Capabilities:
-                        for caps, results in [(permitted_caps, permitted), (inheritable_caps, inheritable)]:
-                            # CAP_TO_INDEX
-                            cap_index = capability.value >> 5
-                            if cap_index >= len(caps):
-                                # We loop over all capabilities, but might only have a version 1 caps list
-                                continue
-
-                            if caps[cap_index] & (1 << (capability.value & 31)) != 0:
-                                results.append(capability.name)
-
-                    yield CapabilityRecord(
-                        record=record,
-                        permitted=permitted,
-                        inheritable=inheritable,
-                        effective=magic_etc & VFS_CAP_FLAGS_EFFECTIVE != 0,
-                        rootid=rootid,
-                        _target=self.target,
-                    )
+                    permitted, inheritable, effective, root_id = parse_attr(attr.value)
+                except ValueError as e:
+                    self.target.log.warning("Could not parse attributes for entry %s: %s", entry, str(e.value))
+                    self.target.log.debug("", exc_info=e)
+
+                yield CapabilityRecord(
+                    ts_mtime=entry.lstat().st_mtime,
+                    path=self.target.fs.path(entry.path),
+                    permitted=permitted,
+                    inheritable=inheritable,
+                    effective=effective,
+                    root_id=root_id,
+                    _target=self.target,
+                )
+
+
+def parse_attr(attr: bytes) -> tuple[list[str], list[str], bool, int]:
+    """Efficiently parse a Linux xattr capability struct.
+
+    Returns:
+        A tuple of permitted capability names, inheritable capability names, effective flag and ``root_id``.
+    """
+    buf = BytesIO(attr)
+
+    # The struct is small enough we can just use int.from_bytes
+    magic_etc = int.from_bytes(buf.read(4), "little")
+    effective = magic_etc & VFS_CAP_FLAGS_EFFECTIVE != 0
+    cap_revision = magic_etc & VFS_CAP_REVISION_MASK
+
+    permitted_caps = []
+    inheritable_caps = []
+    root_id = None
+
+    if cap_revision == VFS_CAP_REVISION_1:
+        num_caps = VFS_CAP_U32_1
+        data_len = (1 + 2 * VFS_CAP_U32_1) * 4
+
+    elif cap_revision == VFS_CAP_REVISION_2:
+        num_caps = VFS_CAP_U32_2
+        data_len = (1 + 2 * VFS_CAP_U32_2) * 4
+
+    elif cap_revision == VFS_CAP_REVISION_3:
+        num_caps = VFS_CAP_U32_3
+        data_len = (2 + 2 * VFS_CAP_U32_2) * 4
+
+    else:
+        raise ValueError("Unexpected capability revision '%s'" % cap_revision)
+
+    if data_len != (actual_len := len(attr)):
+        raise ValueError("Unexpected capability length (%s vs %s)", data_len, actual_len)
+
+    for _ in range(num_caps):
+        permitted_caps.append(int.from_bytes(buf.read(4), "little"))
+        inheritable_caps.append(int.from_bytes(buf.read(4), "little"))
+
+    if cap_revision == VFS_CAP_REVISION_3:
+        root_id = int.from_bytes(buf.read(4), "little")
+
+    permitted = []
+    inheritable = []
+
+    for capability in Capabilities:
+        for caps, results in [(permitted_caps, permitted), (inheritable_caps, inheritable)]:
+            # CAP_TO_INDEX
+            cap_index = capability.value >> 5
+            if cap_index >= len(caps):
+                # We loop over all capabilities, but might only have a version 1 caps list
+                continue
+
+            if caps[cap_index] & (1 << (capability.value & 31)) != 0:
+                results.append(capability.name)
+
+    return permitted, inheritable, effective, root_id

dissect/target/plugins/filesystem/walkfs.py

@@ -1,12 +1,11 @@
-from typing import Iterable
+from typing import Iterator
 
 from dissect.util.ts import from_unix
 
 from dissect.target.exceptions import FileNotFoundError, UnsupportedPluginError
-from dissect.target.filesystem import LayerFilesystemEntry
-from dissect.target.helpers.fsutil import TargetPath
+from dissect.target.filesystem import FilesystemEntry, LayerFilesystemEntry
 from dissect.target.helpers.record import TargetRecordDescriptor
-from dissect.target.plugin import Plugin, export
+from dissect.target.plugin import Plugin, arg, export
 from dissect.target.target import Target
 
 FilesystemRecord = TargetRecordDescriptor(
@@ -30,37 +29,49 @@ FilesystemRecord = TargetRecordDescriptor(
 class WalkFSPlugin(Plugin):
     def check_compatible(self) -> None:
         if not len(self.target.filesystems):
-            raise UnsupportedPluginError("No filesystems found")
+            raise UnsupportedPluginError("No filesystems to walk")
 
     @export(record=FilesystemRecord)
-    def walkfs(self) -> Iterable[FilesystemRecord]:
+    @arg("--walkfs-path", default="/", help="path to recursively walk")
+    def walkfs(self, walkfs_path: str = "/") -> Iterator[FilesystemRecord]:
         """Walk a target's filesystem and return all filesystem entries."""
-        for path_entries, _, files in self.target.fs.walk_ext("/"):
-            entries = [path_entries[-1]] + files
-            for entry in entries:
-                path = self.target.fs.path(entry.path)
-                try:
-                    record = generate_record(self.target, path)
-                except FileNotFoundError:
-                    continue
-                yield record
+        for entry in self.target.fs.recurse(walkfs_path):
+            try:
+                yield generate_record(self.target, entry)
 
+            except FileNotFoundError as e:
+                self.target.log.warning("File not found: %s", entry)
+                self.target.log.debug("", exc_info=e)
+            except Exception as e:
+                self.target.log.warning("Exception generating record for: %s", entry)
+                self.target.log.debug("", exc_info=e)
+                continue
+
+
+def generate_record(target: Target, entry: FilesystemEntry) -> FilesystemRecord:
+    """Generate a :class:`FilesystemRecord` from the given :class:`FilesystemEntry`.
+
+    Args:
+        target: :class:`Target` instance
+        entry: :class:`FilesystemEntry` instance
+
+    Returns:
+        Generated :class:`FilesystemRecord` for the given :class:`FilesystemEntry`.
+    """
+    stat = entry.lstat()
 
-def generate_record(target: Target, path: TargetPath) -> FilesystemRecord:
-    stat = path.lstat()
-    btime = from_unix(stat.st_birthtime) if stat.st_birthtime else None
-    entry = path.get()
     if isinstance(entry, LayerFilesystemEntry):
         fs_types = [sub_entry.fs.__type__ for sub_entry in entry.entries]
     else:
         fs_types = [entry.fs.__type__]
+
     return FilesystemRecord(
         atime=from_unix(stat.st_atime),
         mtime=from_unix(stat.st_mtime),
         ctime=from_unix(stat.st_ctime),
-        btime=btime,
+        btime=from_unix(stat.st_birthtime) if stat.st_birthtime else None,
         ino=stat.st_ino,
-        path=path,
+        path=entry.path,
         size=stat.st_size,
         mode=stat.st_mode,
         uid=stat.st_uid,

{dissect.target-3.19.dev46.dist-info → dissect.target-3.19.dev48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev46
+Version: 3.19.dev48
 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.dev46.dist-info → dissect.target-3.19.dev48.dist-info}/RECORD

@@ -1,7 +1,7 @@
 dissect/target/__init__.py,sha256=Oc7ounTgq2hE4nR6YcNabetc7SQA40ldSa35VEdZcQU,63
 dissect/target/container.py,sha256=0YcwcGmfJjhPXUB6DEcjWEoSuAtTDxMDpoTviMrLsxM,9353
 dissect/target/exceptions.py,sha256=ULi7NXlqju_d8KENEL3aimmfKTFfbNssfeWhAnOB654,2972
-dissect/target/filesystem.py,sha256=G1gbOUpnQZyovubYGEUKgaDV0eHH5vE83-0gTc5PZAM,59793
+dissect/target/filesystem.py,sha256=__p2p72B6mKgIiAOj85EC3ESdZ8gjgkm2pt1KKym3h0,60743
 dissect/target/loader.py,sha256=I8WNzDA0SMy42F7zfyBcSKj_VKNv64213WUvtGZ77qE,7374
 dissect/target/plugin.py,sha256=k9xWNnIGQG0DQsq6DKYJ6_DAX1aIA0SjzniWmOwX8O4,50317
 dissect/target/report.py,sha256=06uiP4MbNI8cWMVrC1SasNS-Yg6ptjVjckwj8Yhe0Js,7958
@@ -32,13 +32,13 @@ dissect/target/filesystems/exfat.py,sha256=PRkZPUVN5NlgB1VetFtywdNgF6Yj5OBtF5a25
 dissect/target/filesystems/extfs.py,sha256=pFv1dyqqTnImpMuy-slAqnnLVfteV9tS03AsG-svN9E,4776
 dissect/target/filesystems/fat.py,sha256=ZSw-wS57vo5eIXJndfI1rZkGu_qh-vyioMzCZFZ_UTE,4611
 dissect/target/filesystems/ffs.py,sha256=Wu8sS1jjmD0QXXcAaD2h_zzfvinjco8qvj0hErufZ-4,4555
-dissect/target/filesystems/itunes.py,sha256=6LPUHSf2qpHacMgA4bdlEKUIV_BaLxmIxyLESXqNexI,6345
+dissect/target/filesystems/itunes.py,sha256=w2lcWv6jlBPm84tsGZehxKBMXXyuW3KlmwVTF4ssQec,6395
 dissect/target/filesystems/jffs.py,sha256=Ceqa5Em2pepnXMH_XZFmSNjQyWPo1uWTthBFSMWfKRo,3926
 dissect/target/filesystems/ntfs.py,sha256=fGgCKjdO5GrPC21DDr0SwIxmwR7KruNIqGUzysboirA,7068
 dissect/target/filesystems/overlay.py,sha256=-dqWuMWLcq3usKbJYh0MW-qyp4dfLlOAh2z6FjNPu9I,4314
 dissect/target/filesystems/smb.py,sha256=uxfcOWwEoDCw8Qpsa94T5Pn-SKd4WXs4OOrzVVI55d8,6406
 dissect/target/filesystems/squashfs.py,sha256=ehzlThXB7n96XUvQnsK5tWLsA9HIxYN-Zxl7aO9D7ts,3921
-dissect/target/filesystems/tar.py,sha256=kQNhcEDPX005svse039OeR2AGSDigGuGz2AKoVrgg84,5692
+dissect/target/filesystems/tar.py,sha256=EJyvRCU6H7eu0exC0tQggyAZKZ3JFFaihYyx9SIQNqk,5742
 dissect/target/filesystems/vmfs.py,sha256=sRtYBUAKTKcHrjCXqpFJ8GIVU-ERjqxhB2zXBndtcXU,4955
 dissect/target/filesystems/vmtar.py,sha256=LlKWkTIuLemQmG9yGqL7980uC_AOL77_GWhbJc_grSk,804
 dissect/target/filesystems/xfs.py,sha256=kIyFGKYlyFYC7H3jaEv-lNKtBW4ZkD92H0WpfGcr1ww,4498
@@ -50,7 +50,7 @@ dissect/target/helpers/configutil.py,sha256=AEnkMQ0e6PncvCqGa-ACzBQWQBhMGBCzO5qz
 dissect/target/helpers/cyber.py,sha256=WnJlk-HqAETmDAgLq92JPxyDLxvzSoFV_WrO-odVKBI,16805
 dissect/target/helpers/descriptor_extensions.py,sha256=uT8GwznfDAiIgMM7JKKOY0PXKMv2c0GCqJTCkWFgops,2605
 dissect/target/helpers/docs.py,sha256=J5U65Y3yOTqxDEZRCdrEmO63XQCeDzOJea1PwPM6Cyc,5146
-dissect/target/helpers/fsutil.py,sha256=EK1idVnD-3d2P5wTa6it-BQL4YCgbW2ZzNIM7yMiCpU,19871
+dissect/target/helpers/fsutil.py,sha256=y-k8ni04pHMODkgN7clTqdx-3tnFbUr0ubjJEaWOOqY,20504
 dissect/target/helpers/hashutil.py,sha256=bYAGEjyYyxuCTziO4kCx6srzY1Cm-PXmayRRcxt5ca4,1061
 dissect/target/helpers/keychain.py,sha256=wYH0sf7eaxP0bZTo80RF_BQMWulCWmIQ8Tzt9K5TSNQ,3611
 dissect/target/helpers/lazy.py,sha256=823VtmdWsbJyVZvNWopDhQdqq2i1xtj6b8IKfveboKw,1771
@@ -169,7 +169,7 @@ dissect/target/plugins/filesystem/acquire_handles.py,sha256=-pX_akH5GrYe0HofXOa2
 dissect/target/plugins/filesystem/acquire_hash.py,sha256=OVxI19-Bl1tdqCiFMscFMLmyoiBOsuAjL-Q8aQpEwl0,1441
 dissect/target/plugins/filesystem/icat.py,sha256=bOMi04IlljnKwxTWTZJKtK7RxKnabFu3WcXyUwzkE-4,4090
 dissect/target/plugins/filesystem/resolver.py,sha256=HfyASUFV4F9uD-yFXilFpPTORAsRDvdmTvuYHgOaOWg,4776
-dissect/target/plugins/filesystem/walkfs.py,sha256=e8HEZcV5Wiua26FGWL3xgiQ_PIhcNvGI5KCdsAx2Nmo,2298
+dissect/target/plugins/filesystem/walkfs.py,sha256=rklbN805roy2fKAQe5L1JhTvI0qNgGS70ZNGFwevLB0,2740
 dissect/target/plugins/filesystem/yara.py,sha256=zh4hU3L_egddLqDeaHDVuCWYhTlNzPYPVak36Q6IMxI,6621
 dissect/target/plugins/filesystem/ntfs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dissect/target/plugins/filesystem/ntfs/mft.py,sha256=WzvKSlH4egvDsuonRQ3AjYS59t9jjFX_-GOsAPLUeSk,12418
@@ -177,7 +177,7 @@ dissect/target/plugins/filesystem/ntfs/mft_timeline.py,sha256=vvNFAZbr7s3X2OTYf4
 dissect/target/plugins/filesystem/ntfs/usnjrnl.py,sha256=uiT1ipmcAo__6VIUi8R_vvIu22vdnjMACKwLSAbzYjs,3704
 dissect/target/plugins/filesystem/ntfs/utils.py,sha256=xG7Lgw9NX4tDDrZVRm0vycFVJTOM7j-HrjqzDh0f4uA,3136
 dissect/target/plugins/filesystem/unix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dissect/target/plugins/filesystem/unix/capability.py,sha256=oTJVEr8Yszejd-FxU0D8J49ATxNrJOcUnBFIc96k8kg,5920
+dissect/target/plugins/filesystem/unix/capability.py,sha256=WScVTW9bZBsH36ZRsAUTZzl9yXG4rglv_MaieWD5H-w,5752
 dissect/target/plugins/filesystem/unix/suid.py,sha256=Q0Y5CyPm34REruyZYP5siFAka4i7QEOOxZ9K2L-SxPY,1290
 dissect/target/plugins/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dissect/target/plugins/general/config.py,sha256=Mdy9uhWn4OJ96zfXpLgjVifV5SrViqHnpSnKhC1mjZE,3432
@@ -356,10 +356,10 @@ dissect/target/volumes/luks.py,sha256=OmCMsw6rCUXG1_plnLVLTpsvE1n_6WtoRUGQbpmu1z
 dissect/target/volumes/lvm.py,sha256=wwQVR9I3G9YzmY6UxFsH2Y4MXGBcKL9aayWGCDTiWMU,2269
 dissect/target/volumes/md.py,sha256=7ShPtusuLGaIv27SvEETtgsuoQyAa4iAAeOR1NEaajI,1689
 dissect/target/volumes/vmfs.py,sha256=-LoUbn9WNwTtLi_4K34uV_-wDw2W5hgaqxZNj4UmqAQ,1730
-dissect.target-3.19.dev46.dist-info/COPYRIGHT,sha256=m-9ih2RVhMiXHI2bf_oNSSgHgkeIvaYRVfKTwFbnJPA,301
-dissect.target-3.19.dev46.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-dissect.target-3.19.dev46.dist-info/METADATA,sha256=KqAZhon-mJ3zlkhXprWA1AQGJ5atgKACGFMvgTKsayo,12897
-dissect.target-3.19.dev46.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
-dissect.target-3.19.dev46.dist-info/entry_points.txt,sha256=BWuxAb_6AvUAQpIQOQU0IMTlaF6TDht2AIZK8bHd-zE,492
-dissect.target-3.19.dev46.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
-dissect.target-3.19.dev46.dist-info/RECORD,,
+dissect.target-3.19.dev48.dist-info/COPYRIGHT,sha256=m-9ih2RVhMiXHI2bf_oNSSgHgkeIvaYRVfKTwFbnJPA,301
+dissect.target-3.19.dev48.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+dissect.target-3.19.dev48.dist-info/METADATA,sha256=rm0EHsiugMzObZ-OiOxBChll3DHKnBCw6oJm3dU2e4s,12897
+dissect.target-3.19.dev48.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+dissect.target-3.19.dev48.dist-info/entry_points.txt,sha256=BWuxAb_6AvUAQpIQOQU0IMTlaF6TDht2AIZK8bHd-zE,492
+dissect.target-3.19.dev48.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
+dissect.target-3.19.dev48.dist-info/RECORD,,

{dissect.target-3.19.dev46.dist-info → dissect.target-3.19.dev48.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any