dissect.target 3.14.dev28__py3-none-any.whl → 3.15__py3-none-any.whl

dissect/target/containers/ewf.py

@@ -19,7 +19,7 @@ class EwfContainer(Container):
         if hasattr(fhs[0], "read"):
             self.ewf = EWF(fhs)
         else:
-            self.ewf = EWF([path.open("rb") for path in find_files(fhs[0])])
+            self.ewf = EWF(find_files(fhs[0]))
 
         self._stream = self.ewf.open()
         super().__init__(fh, self.ewf.size, *args, **kwargs)

dissect/target/containers/vhd.py

@@ -20,8 +20,11 @@ class VhdContainer(Container):
 
     @staticmethod
     def _detect_fh(fh: BinaryIO, original: Union[list, BinaryIO]) -> bool:
-        fh.seek(-512, io.SEEK_END)
-        return b"conectix" in fh.read(9)
+        try:
+            fh.seek(-512, io.SEEK_END)
+            return b"conectix" in fh.read(9)
+        except OSError:
+            return False
 
     @staticmethod
     def detect_path(path: Path, original: Union[list, BinaryIO]) -> bool:

dissect/target/filesystem.py

@@ -13,7 +13,6 @@ from typing import (
     BinaryIO,
     Callable,
     Iterator,
-    List,
     Optional,
     Type,
     Union,
@@ -217,7 +216,7 @@ class Filesystem:
         """
         return self.get(path).scandir()
 
-    def listdir(self, path: str) -> List[str]:
+    def listdir(self, path: str) -> list[str]:
         """List the contents of a directory as strings.
 
         Args:
@@ -228,7 +227,7 @@ class Filesystem:
         """
         return list(self.iterdir(path))
 
-    def listdir_ext(self, path: str) -> List[FilesystemEntry]:
+    def listdir_ext(self, path: str) -> list[FilesystemEntry]:
         """List the contents of a directory as FilesystemEntry's.
 
         Args:
@@ -487,7 +486,7 @@ class Filesystem:
         """
         return self.get(path).sha256()
 
-    def hash(self, path: str, algos: Optional[Union[List[str], List[Callable]]] = None) -> tuple[str]:
+    def hash(self, path: str, algos: Optional[Union[list[str], list[Callable]]] = None) -> tuple[str]:
         """Calculate the digest of the contents of ``path``, using the ``algos`` algorithms.
 
         Args:
@@ -574,7 +573,7 @@ class FilesystemEntry:
         """
         raise NotImplementedError()
 
-    def listdir(self) -> List[str]:
+    def listdir(self) -> list[str]:
         """List the contents of a directory as strings.
 
         Returns:
@@ -582,7 +581,7 @@ class FilesystemEntry:
         """
         return list(self.iterdir())
 
-    def listdir_ext(self) -> List[FilesystemEntry]:
+    def listdir_ext(self) -> list[FilesystemEntry]:
         """List the contents of a directory as FilesystemEntry's.
 
         Returns:
@@ -823,7 +822,7 @@ class FilesystemEntry:
         """
         return hashutil.sha256(self.open())
 
-    def hash(self, algos: Optional[Union[List[str], List[Callable]]] = None) -> tuple[str]:
+    def hash(self, algos: Optional[Union[list[str], list[Callable]]] = None) -> tuple[str]:
         """Calculate the digest of this entry, using the ``algos`` algorithms.
 
         Args:
@@ -906,7 +905,7 @@ class VirtualDirectory(FilesystemEntry):
 
     def _stat(self) -> fsutil.stat_result:
         path_addr = fsutil.generate_addr(self.path, alt_separator=self.fs.alt_separator)
-        return fsutil.stat_result([stat.S_IFDIR, path_addr, id(self.fs), 0, 0, 0, 0, 0, 0, 0])
+        return fsutil.stat_result([stat.S_IFDIR, path_addr, id(self.fs), 1, 0, 0, 0, 0, 0, 0])
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         if self.top:
@@ -928,10 +927,10 @@ class VirtualDirectory(FilesystemEntry):
         return False
 
     def readlink(self) -> str:
-        raise NotASymlinkError()
+        raise NotASymlinkError(self.path)
 
     def readlink_ext(self) -> FilesystemEntry:
-        raise NotASymlinkError()
+        raise NotASymlinkError(self.path)
 
 
 class VirtualFileHandle(io.RawIOBase):
@@ -994,10 +993,10 @@ class VirtualFile(FilesystemEntry):
         return False
 
     def readlink(self) -> str:
-        raise FilesystemError(f"{self.__class__.__name__} does not support symlinks.")
+        raise NotASymlinkError(self.path)
 
     def readlink_ext(self) -> FilesystemEntry:
-        raise FilesystemError(f"{self.__class__.__name__} does not support symlinks.")
+        raise NotASymlinkError(self.path)
 
 
 class MappedFile(VirtualFile):
@@ -1073,13 +1072,19 @@ class VirtualSymlink(FilesystemEntry):
         if not follow_symlinks:
             return False
 
-        return self.readlink_ext().is_dir()
+        try:
+            return self.readlink_ext().is_dir()
+        except FileNotFoundError:
+            return False
 
     def is_file(self, follow_symlinks: bool = True) -> bool:
         if not follow_symlinks:
             return False
 
-        return self.readlink_ext().is_file()
+        try:
+            return self.readlink_ext().is_file()
+        except FileNotFoundError:
+            return False
 
     def is_symlink(self) -> bool:
         return True
@@ -1234,12 +1239,22 @@ class VirtualFilesystem(Filesystem):
             directory.add(entry_name, entry)
 
     def link(self, src: str, dst: str) -> None:
-        """Hard link a FilesystemEntry to another location."""
+        """Hard link a FilesystemEntry to another location.
+
+        Args:
+            src: The path to the target of the link.
+            dst: The path to the link.
+        """
         self.map_file_entry(dst, self.get(src))
 
     def symlink(self, src: str, dst: str) -> None:
-        """Create a symlink to another location."""
-        src = fsutil.normalize(src, alt_separator=self.alt_separator).strip("/")
+        """Create a symlink to another location.
+
+        Args:
+            src: The path to the target of the symlink.
+            dst: The path to the symlink.
+        """
+        src = fsutil.normalize(src, alt_separator=self.alt_separator).rstrip("/")
         dst = fsutil.normalize(dst, alt_separator=self.alt_separator).strip("/")
         self.map_file_entry(dst, VirtualSymlink(self, dst, src))
 
@@ -1471,7 +1486,7 @@ class RootFilesystemEntry(FilesystemEntry):
     def readlink(self) -> str:
         self.fs.target.log.debug("%r::readlink()", self)
         if not self.is_symlink():
-            raise FilesystemError(f"Not a link: {self}")
+            raise NotASymlinkError(f"Not a link: {self}")
         return self._exec("readlink")
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
@@ -1533,6 +1548,8 @@ def open(fh: BinaryIO, *args, **kwargs) -> Filesystem:
             except ImportError as e:
                 log.info("Failed to import %s", filesystem)
                 log.debug("", exc_info=e)
+            except Exception as e:
+                raise FilesystemError(f"Failed to open filesystem for {fh}", cause=e)
     finally:
         fh.seek(offset)
 
@@ -1572,3 +1589,4 @@ register("exfat", "ExfatFilesystem")
 register("squashfs", "SquashFSFilesystem")
 register("zip", "ZipFilesystem")
 register("ad1", "AD1Filesystem")
+register("jffs", "JFFSFilesystem")

dissect/target/filesystems/dir.py

@@ -60,9 +60,12 @@ class DirectoryFilesystemEntry(FilesystemEntry):
         return self.fs.get(path)
 
     def open(self) -> BinaryIO:
-        if self.is_dir():
-            raise IsADirectoryError(self.path)
-        return self._resolve().entry.open("rb")
+        try:
+            if self.is_dir():
+                raise IsADirectoryError(self.path)
+            return self._resolve().entry.open("rb")
+        except (PermissionError, OSError) as e:
+            raise FilesystemError from e
 
     def iterdir(self) -> Iterator[str]:
         if not self.is_dir():
@@ -104,7 +107,10 @@ class DirectoryFilesystemEntry(FilesystemEntry):
             return False
 
     def is_symlink(self) -> bool:
-        return self.entry.is_symlink()
+        try:
+            return self.entry.is_symlink()
+        except (FilesystemError, OSError):
+            return False
 
     def readlink(self) -> str:
         return os.readlink(self.entry)  # Python 3.7 compatibility

dissect/target/filesystems/jffs.py

@@ -0,0 +1,122 @@
+from typing import BinaryIO, Iterator, Optional
+
+from dissect.jffs import jffs2
+from dissect.jffs.c_jffs2 import c_jffs2
+
+from dissect.target.exceptions import (
+    FileNotFoundError,
+    FilesystemError,
+    IsADirectoryError,
+    NotADirectoryError,
+    NotASymlinkError,
+)
+from dissect.target.filesystem import Filesystem, FilesystemEntry
+from dissect.target.helpers import fsutil
+
+
+class JFFSFilesystem(Filesystem):
+    __type__ = "jffs"
+
+    def __init__(self, fh: BinaryIO, *args, **kwargs):
+        super().__init__(fh, *args, **kwargs)
+        self.jffs2 = jffs2.JFFS2(fh)
+
+    @staticmethod
+    def _detect(fh: BinaryIO) -> bool:
+        return int.from_bytes(fh.read(2), "little") in (
+            c_jffs2.JFFS2_MAGIC_BITMASK,
+            c_jffs2.JFFS2_OLD_MAGIC_BITMASK,
+        )
+
+    def get(self, path: str) -> FilesystemEntry:
+        return JFFSFilesystemEntry(self, path, self._get_node(path))
+
+    def _get_node(self, path: str, node: Optional[jffs2.INode] = None) -> jffs2.INode:
+        try:
+            return self.jffs2.get(path, node)
+        except jffs2.FileNotFoundError as e:
+            raise FileNotFoundError(path, cause=e)
+        except jffs2.NotADirectoryError as e:
+            raise NotADirectoryError(path, cause=e)
+        except jffs2.NotASymlinkError as e:
+            raise NotASymlinkError(path, cause=e)
+        except jffs2.Error as e:
+            raise FileNotFoundError(path, cause=e)
+
+
+class JFFSFilesystemEntry(FilesystemEntry):
+    fs: JFFSFilesystem
+    entry: jffs2.INode
+
+    def get(self, path: str) -> FilesystemEntry:
+        entry_path = fsutil.join(self.path, path, alt_separator=self.fs.alt_separator)
+        entry = self.fs._get_node(path, self.entry)
+        return JFFSFilesystemEntry(self.fs, entry_path, entry)
+
+    def open(self) -> BinaryIO:
+        if self.is_dir():
+            raise IsADirectoryError(self.path)
+        return self._resolve().entry.open()
+
+    def _iterdir(self) -> Iterator[tuple[str, jffs2.INode]]:
+        if not self.is_dir():
+            raise NotADirectoryError(self.path)
+
+        if self.is_symlink():
+            yield from self.readlink_ext().iterdir()
+        else:
+            yield from self.entry.iterdir()
+
+    def iterdir(self) -> Iterator[str]:
+        for name, _ in self._iterdir():
+            yield name
+
+    def scandir(self) -> Iterator[FilesystemEntry]:
+        for name, entry in self._iterdir():
+            entry_path = fsutil.join(self.path, name, alt_separator=self.fs.alt_separator)
+            yield JFFSFilesystemEntry(self.fs, entry_path, entry)
+
+    def is_dir(self, follow_symlinks: bool = False) -> bool:
+        try:
+            return self._resolve(follow_symlinks).entry.is_dir()
+        except FilesystemError:
+            return False
+
+    def is_file(self, follow_symlinks: bool = False) -> bool:
+        try:
+            return self._resolve(follow_symlinks).entry.is_file()
+        except FilesystemError:
+            return False
+
+    def is_symlink(self) -> bool:
+        return self.entry.is_symlink()
+
+    def readlink(self) -> str:
+        if not self.is_symlink():
+            raise NotASymlinkError()
+
+        return self.entry.link
+
+    def stat(self, follow_symlinks: bool = False) -> fsutil.stat_result:
+        return self._resolve(follow_symlinks).lstat()
+
+    def lstat(self) -> fsutil.stat_result:
+        node = self.entry.inode
+
+        # mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime
+        st_info = fsutil.stat_result(
+            [
+                self.entry.mode,
+                self.entry.inum,
+                id(self.fs),
+                1,  # TODO: properly calculate nlink in dissect.jffs
+                node.uid,
+                node.gid,
+                node.isize,
+                self.entry.atime.timestamp(),
+                self.entry.mtime.timestamp(),
+                self.entry.ctime.timestamp(),
+            ]
+        )
+
+        return st_info