dissect.target 3.18.dev16__tar.gz → 3.19__tar.gz

{dissect_target-3.18.dev16/dissect.target.egg-info → dissect_target-3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.18.dev16
+Version: 3.19
 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.15.0
+Requires-Dist: flow.record~=3.16.0
 Requires-Dist: structlog
 Provides-Extra: full
 Requires-Dist: asn1crypto; extra == "full"
@@ -44,6 +44,7 @@ Requires-Dist: dissect.extfs<4,>=3; extra == "full"
 Requires-Dist: dissect.fat<4,>=3; extra == "full"
 Requires-Dist: dissect.ffs<4,>=3; extra == "full"
 Requires-Dist: dissect.jffs<2,>=1; extra == "full"
+Requires-Dist: dissect.ole<4,>=3; extra == "full"
 Requires-Dist: dissect.shellitem<4,>=3; extra == "full"
 Requires-Dist: dissect.squashfs<2,>=1; extra == "full"
 Requires-Dist: dissect.sql<4,>=3; extra == "full"
@@ -154,16 +155,19 @@ Opening a shell on a target is straight-forward. You can do so by specifying a p
 
 ```bash
     target-shell targets/EXAMPLE.vmx
-    EXAMPLE /> help
+    WIN-EXAMPLE:/$ help
 
     Documented commands (type help <topic>):
     ========================================
-    cat    disks  filesystems  help     less  python    save
-    cd     exit   find         hexdump  ls    readlink  stat
-    clear  file   hash         info     pwd   registry  volumes
+    attr   cls    enter        find     info  man       registry  volumes
+    cat    cyber  exit         hash     less  pwd       save      zcat   
+    cd     debug  file         help     ll    python    stat      zless  
+    clear  disks  filesystems  hexdump  ls    readlink  tree    
 
-    EXAMPLE /> ls
+    WIN-EXAMPLE:/$ ls
+    $fs$
     c:
+    efi
     sysvol
 ```
 

{dissect_target-3.18.dev16 → dissect_target-3.19}/README.md

@@ -58,16 +58,19 @@ Opening a shell on a target is straight-forward. You can do so by specifying a p
 
 ```bash
     target-shell targets/EXAMPLE.vmx
-    EXAMPLE /> help
+    WIN-EXAMPLE:/$ help
 
     Documented commands (type help <topic>):
     ========================================
-    cat    disks  filesystems  help     less  python    save
-    cd     exit   find         hexdump  ls    readlink  stat
-    clear  file   hash         info     pwd   registry  volumes
+    attr   cls    enter        find     info  man       registry  volumes
+    cat    cyber  exit         hash     less  pwd       save      zcat   
+    cd     debug  file         help     ll    python    stat      zless  
+    clear  disks  filesystems  hexdump  ls    readlink  tree    
 
-    EXAMPLE /> ls
+    WIN-EXAMPLE:/$ ls
+    $fs$
     c:
+    efi
     sysvol
 ```
 

{dissect_target-3.18.dev16 → dissect_target-3.19}/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-3.18.dev16 → dissect_target-3.19}/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.18.dev16 → dissect_target-3.19}/dissect/target/filesystems/extfs.py

@@ -134,6 +134,10 @@ class ExtFilesystemEntry(FilesystemEntry):
         st_info.st_mtime_ns = self.entry.mtime_ns
         st_info.st_ctime_ns = self.entry.ctime_ns
 
+        # Set blocks
+        st_info.st_blocks = self.entry.inode.i_blocks_lo
+        st_info.st_blksize = self.entry.extfs.block_size
+
         return st_info
 
     def attr(self) -> Any:

{dissect_target-3.18.dev16 → dissect_target-3.19}/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-3.18.dev16 → dissect_target-3.19}/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-3.19/dissect/target/filesystems/zip.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import logging
+import stat
+import zipfile
+from datetime import datetime, timezone
+from typing import BinaryIO, Iterator
+
+from dissect.util.stream import BufferedStream
+
+from dissect.target.exceptions import (
+    FileNotFoundError,
+    FilesystemError,
+    IsADirectoryError,
+    NotADirectoryError,
+    NotASymlinkError,
+)
+from dissect.target.filesystem import (
+    Filesystem,
+    FilesystemEntry,
+    VirtualDirectory,
+    VirtualFilesystem,
+)
+from dissect.target.helpers import fsutil
+
+log = logging.getLogger(__name__)
+
+
+class ZipFilesystem(Filesystem):
+    """Filesystem implementation for zip files.
+
+    Python does not have symlink support in the zipfile module, so that's not currently supported.
+    See https://github.com/python/cpython/issues/82102 for more information.
+    """
+
+    __type__ = "zip"
+
+    def __init__(
+        self,
+        fh: BinaryIO,
+        base: str | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(fh, *args, **kwargs)
+
+        fh.seek(0)
+
+        self.zip = zipfile.ZipFile(fh, mode="r")
+        self.base = base or ""
+
+        self._fs = VirtualFilesystem(alt_separator=self.alt_separator, case_sensitive=self.case_sensitive)
+
+        for member in self.zip.infolist():
+            mname = member.filename.strip("/")
+            if not mname.startswith(self.base) or mname == ".":
+                continue
+
+            rel_name = fsutil.normpath(mname[len(self.base) :], alt_separator=self.alt_separator)
+            self._fs.map_file_entry(rel_name, ZipFilesystemEntry(self, rel_name, member))
+
+    @staticmethod
+    def _detect(fh: BinaryIO) -> bool:
+        """Detect a zip file on a given file-like object."""
+        return zipfile.is_zipfile(fh)
+
+    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)
+
+
+# Note: We subclass from VirtualDirectory because VirtualFilesystem is currently only compatible with VirtualDirectory
+# Subclass from VirtualDirectory so we get that compatibility for free, and override the rest to do our own thing
+class ZipFilesystemEntry(VirtualDirectory):
+    fs: ZipFilesystem
+    entry: zipfile.ZipInfo
+
+    def __init__(self, fs: ZipFilesystem, path: str, entry: zipfile.ZipInfo):
+        super().__init__(fs, path)
+        self.entry = entry
+
+    def open(self) -> BinaryIO:
+        if self.is_dir():
+            raise IsADirectoryError(self.path)
+
+        if self.is_symlink():
+            return self._resolve().open()
+
+        try:
+            return BufferedStream(self.fs.zip.open(self.entry), size=self.entry.file_size)
+        except Exception:
+            raise FileNotFoundError(self.path)
+
+    def iterdir(self) -> Iterator[str]:
+        if not self.is_dir():
+            raise NotADirectoryError(self.path)
+
+        entry = self._resolve()
+        if isinstance(entry, ZipFilesystemEntry):
+            yield from super(ZipFilesystemEntry, entry).iterdir()
+        else:
+            yield from entry.iterdir()
+
+    def scandir(self) -> Iterator[FilesystemEntry]:
+        if not self.is_dir():
+            raise NotADirectoryError(self.path)
+
+        entry = self._resolve()
+        if isinstance(entry, ZipFilesystemEntry):
+            yield from super(ZipFilesystemEntry, entry).scandir()
+        else:
+            yield from entry.scandir()
+
+    def is_dir(self, follow_symlinks: bool = True) -> bool:
+        try:
+            entry = self._resolve(follow_symlinks=follow_symlinks)
+        except FilesystemError:
+            return False
+
+        if isinstance(entry, ZipFilesystemEntry):
+            return entry.entry.is_dir()
+        return isinstance(entry, VirtualDirectory)
+
+    def is_file(self, follow_symlinks: bool = True) -> bool:
+        try:
+            entry = self._resolve(follow_symlinks=follow_symlinks)
+        except FilesystemError:
+            return False
+
+        if isinstance(entry, ZipFilesystemEntry):
+            return not entry.entry.is_dir()
+        return False
+
+    def is_symlink(self) -> bool:
+        return stat.S_ISLNK(self.entry.external_attr >> 16)
+
+    def readlink(self) -> str:
+        if not self.is_symlink():
+            raise NotASymlinkError()
+        return self.fs.zip.open(self.entry).read().decode()
+
+    def readlink_ext(self) -> FilesystemEntry:
+        return FilesystemEntry.readlink_ext(self)
+
+    def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self._resolve(follow_symlinks=follow_symlinks).lstat()
+
+    def lstat(self) -> fsutil.stat_result:
+        """Return the stat information of the given path, without resolving links."""
+        # ['mode', 'addr', 'dev', 'nlink', 'uid', 'gid', 'size', 'atime', 'mtime', 'ctime']
+        mode = self.entry.external_attr >> 16
+
+        if self.entry.is_dir() and not stat.S_ISDIR(mode):
+            mode = stat.S_IFDIR | mode
+        elif not self.entry.is_dir() and not stat.S_ISREG(mode):
+            mode = stat.S_IFREG | mode
+
+        return fsutil.stat_result(
+            [
+                mode,
+                self.entry.header_offset,
+                id(self.fs),
+                1,
+                0,
+                0,
+                self.entry.file_size,
+                0,
+                datetime(*self.entry.date_time, tzinfo=timezone.utc).timestamp(),
+                0,
+            ]
+        )

{dissect_target-3.18.dev16 → dissect_target-3.19}/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