dissect.hypervisor 3.19.dev2__tar.gz → 3.20.dev2__tar.gz

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: dissect.hypervisor
-Version: 3.19.dev2
+Version: 3.20.dev2
 Summary: A Dissect module implementing parsers for various hypervisor disk, backup and configuration files
 Author-email: Dissect Team <dissect@fox-it.com>
-License: Affero General Public License v3
+License-Expression: AGPL-3.0-or-later
 Project-URL: homepage, https://dissect.tools
 Project-URL: documentation, https://docs.dissect.tools/en/latest/projects/dissect.hypervisor
 Project-URL: repository, https://github.com/fox-it/dissect.hypervisor
@@ -11,14 +11,13 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Internet :: Log Analysis
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Security
 Classifier: Topic :: Utilities
-Requires-Python: ~=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: COPYRIGHT

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect/hypervisor/__init__.py

@@ -1,8 +1,9 @@
 from dissect.hypervisor.descriptor import hyperv, ovf, pvs, vbox, vmx
-from dissect.hypervisor.disk import hdd, qcow2, vdi, vhd, vhdx, vmdk
+from dissect.hypervisor.disk import asif, hdd, qcow2, vdi, vhd, vhdx, vmdk
 from dissect.hypervisor.util import envelope, vmtar
 
 __all__ = [
+    "asif",
     "envelope",
     "hdd",
     "hyperv",

dissect_hypervisor-3.20.dev2/dissect/hypervisor/disk/asif.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import plistlib
+from functools import cached_property, lru_cache
+from typing import Any, BinaryIO
+from uuid import UUID
+
+from dissect.util.stream import AlignedStream
+
+from dissect.hypervisor.disk.c_asif import c_asif
+from dissect.hypervisor.exceptions import InvalidSignature
+
+
+class ASIF:
+    """Apple Sparse Image Format (ASIF) disk image.
+
+    ASIF disk images are a virtual disk format introduced in macOS Tahoe. They can be used in Apple's Virtualization
+    framework, as well as through Disk Utility.
+
+    An ASIF file is pretty straight forward. There's a small header which, among some other details, contains two
+    directory offsets. Each directory contains a list of tables, which in turn contain a list of data entries. Each data
+    entry points to a chunk of data in the ASIF file. The chunk size is defined in the header and is typically 1 MiB.
+    The chunk size is always a multiple of the block size, which is also defined in the header (typically 512 bytes).
+    Each directory has a version number, and the directory with the highest version number is the active directory. This
+    allows for atomic updates of the directory/table data.
+
+    The maximum virtual disk size seems to be just under 4 PiB, with a small portion at the end reserved for metadata.
+    The actual size of the virtual disk is defined in the header, as well as the maximum size the disk can grow to.
+
+    The offset to the metadata block is typically ``(4 PiB - 1 chunk)``, meaning it's within the reserved area.
+    The metadata block contains a small header and a plist. The plist should contain an ``internal metadata`` and
+    ``user metadata`` dictionary. Besides a "stable uuid", it's unclear what the metadata is used for or how to set it.
+
+    Args:
+        fh: File-like object containing the ASIF image.
+
+    Resources:
+        - Reversing ``diskimagescontroller``
+        - https://developer.apple.com/documentation/virtualization/vzdiskimagestoragedeviceattachment/
+    """
+
+    def __init__(self, fh: BinaryIO):
+        self.fh = fh
+
+        self.header = c_asif.asif_header(fh)
+        if self.header.header_signature != c_asif.ASIF_HEADER_SIGNATURE:
+            raise InvalidSignature(
+                f"Not a valid ASIF image (expected {c_asif.ASIF_HEADER_SIGNATURE:#x}, "
+                f"got {self.header.header_signature:#x})"
+            )
+
+        self.guid = UUID(bytes=self.header.guid)
+        self.block_size = self.header.block_size
+        self.chunk_size = self.header.chunk_size
+        self.size = self.header.sector_count * self.block_size
+        self.max_size = self.header.max_sector_count * self.block_size
+
+        # The following math is taken from the assembly with some creative variable naming
+        # It's possible that some of this can be simplified or the names improved
+        self._blocks_per_chunk = self.chunk_size // self.block_size
+
+        # This check doesn't really make sense, but keep it in for now
+        reserved_size = 4 * self.chunk_size
+        self._num_reserved_table_entries = (
+            1 if reserved_size < self._blocks_per_chunk else reserved_size // self._blocks_per_chunk
+        )
+
+        self._max_table_entries = self.chunk_size >> 3
+        self._num_table_entries = self._max_table_entries - (
+            self._max_table_entries % (self._num_reserved_table_entries + 1)
+        )
+        self._num_reserved_directory_entries = (self._num_reserved_table_entries + self._num_table_entries) // (
+            self._num_reserved_table_entries + 1
+        )
+        self._num_usable_entries = self._num_table_entries - self._num_reserved_directory_entries
+        # This is the size in bytes of data covered by a single table
+        self._size_per_table = self._num_usable_entries * self.chunk_size
+
+        max_size = self.block_size * self.header.max_sector_count
+        self._num_directory_entries = (self._size_per_table + max_size - 1) // self._size_per_table
+
+        self._aligned_table_size = (
+            (self.block_size + 8 * self._num_table_entries - 1) // self.block_size * self.block_size
+        )
+
+        self.directories = sorted(
+            (Directory(self, offset) for offset in self.header.directory_offsets),
+            key=lambda d: d.version,
+            reverse=True,
+        )
+        self.active_directory = self.directories[0]
+
+        self.metadata_header = None
+        self.metadata: dict[str, Any] = {}
+        if self.header.metadata_chunk:
+            # Open the file in reserved mode to read from the reserved area
+            with self.open(reserved=True) as disk:
+                metadata_offset = self.header.metadata_chunk * self.chunk_size
+                disk.seek(metadata_offset)
+                self.metadata_header = c_asif.asif_meta_header(disk)
+
+                if self.metadata_header.header_signature != c_asif.ASIF_META_HEADER_SIGNATURE:
+                    raise InvalidSignature(
+                        f"Invalid a ASIF metadata header (expected {c_asif.ASIF_META_HEADER_SIGNATURE:#x}, "
+                        f"got {self.metadata_header.header_signature:#x})"
+                    )
+
+                disk.seek(metadata_offset + self.metadata_header.header_size)
+                self.metadata = plistlib.loads(disk.read(self.metadata_header.data_size).strip(b"\x00"))
+
+    @property
+    def internal_metadata(self) -> dict[str, Any]:
+        """Get internal metadata from the ASIF image.
+
+        Returns:
+            A dictionary containing the internal metadata.
+        """
+        return self.metadata.get("internal metadata", {})
+
+    @property
+    def user_metadata(self) -> dict[str, Any]:
+        """Get user metadata from the ASIF image.
+
+        Returns:
+            A dictionary containing the user metadata.
+        """
+        return self.metadata.get("user metadata", {})
+
+    def open(self, reserved: bool = False) -> DataStream:
+        """Open a stream to read the ASIF image data.
+
+        Args:
+            reserved: Whether to allow reading into the reserved area of the ASIF image.
+
+        Returns:
+            A stream-like object that can be used to read the image data.
+        """
+        return DataStream(self, reserved)
+
+
+class Directory:
+    """ASIF Directory.
+
+    A directory has a version (``uint64``) followed by a list of table entries (``uint64[]``).
+    The version number is used to determine the active directory, with the highest version being the active one.
+    Each table entry is a chunk number and points to a table in the ASIF image.
+
+    Args:
+        asif: The ASIF image this directory belongs to.
+        offset: Offset of the directory in the ASIF image.
+    """
+
+    def __init__(self, asif: ASIF, offset: int):
+        self.asif = asif
+        self.offset = offset
+
+        self.asif.fh.seek(offset)
+        self.version = c_asif.uint64(self.asif.fh)
+
+        self.table = lru_cache(128)(self.table)
+
+    def __repr__(self) -> str:
+        return f"<Directory offset={self.offset:#x} version={self.version}>"
+
+    @cached_property
+    def entries(self) -> list[int]:
+        """List of table entries in the directory."""
+        # Seek over the version
+        self.asif.fh.seek(self.offset + 8)
+        return c_asif.uint64[self.asif._num_directory_entries](self.asif.fh)
+
+    def table(self, index: int) -> Table:
+        """Get a table from the directory.
+
+        Args:
+            index: Index of the table in the directory.
+        """
+        if index >= self.asif._num_directory_entries:
+            raise IndexError("Table index out of range")
+        return Table(self, index)
+
+
+class Table:
+    """ASIF Table.
+
+    A table contains a list of data entries (``uint64[]``). Each data entry is a chunk number and points to a chunk of
+    data in the ASIF image. Each table covers a fixed amount of data in the virtual disk.
+
+    Data entries have 55 bits usable for the chunk number and 9 bits reserved for flags.
+
+    .. rubric :: Encoding
+    .. code-block:: c
+
+        0b00000000 01111111 11111111 11111111 11111111 11111111 11111111 11111111  (chunk number)
+        0b00111111 10000000 00000000 00000000 00000000 00000000 00000000 00000000  (reserved)
+        0b01000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000  (entry dirty)
+        0b10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000  (content dirty)
+
+    Args:
+        directory: The directory this table belongs to.
+        index: Index of the table in the directory.
+    """
+
+    def __init__(self, directory: Directory, index: int):
+        self.asif = directory.asif
+        self.directory = directory
+        self.index = index
+
+        self.offset = self.directory.entries[index] * self.asif.chunk_size
+        self.virtual_offset = index * self.asif._size_per_table
+
+    def __repr__(self) -> str:
+        return f"<Table index={self.index} offset={self.offset:#x} virtual_offset={self.virtual_offset:#x}>"
+
+    @cached_property
+    def entries(self) -> list[int]:
+        """List of data entries in the table."""
+        self.asif.fh.seek(self.offset)
+        return c_asif.uint64[self.asif._num_table_entries](self.asif.fh)
+
+
+class DataStream(AlignedStream):
+    """Stream to read data from an ASIF image.
+
+    Args:
+        asif: The ASIF image to read from.
+        reserved: Whether to allow reading into the reserved area of the ASIF image.
+    """
+
+    def __init__(self, asif: ASIF, reserved: bool = False):
+        super().__init__(asif.max_size if reserved else asif.size, align=asif.chunk_size)
+        self.asif = asif
+        self.reserved = reserved
+        self.directory = asif.active_directory
+
+    def _read(self, offset: int, length: int) -> bytes:
+        result = []
+        while length:
+            table = self.directory.table(offset // self.asif._size_per_table)
+            relative_block_index = (offset // self.asif.block_size) - (table.virtual_offset // self.asif.block_size)
+            data_idx = (
+                relative_block_index // self.asif._blocks_per_chunk
+                + relative_block_index // self.asif._blocks_per_chunk * self.asif._num_reserved_table_entries
+            ) // self.asif._num_reserved_table_entries
+
+            # 0x8000000000000000 = content dirty bit
+            # 0x4000000000000000 = entry dirty bit
+            # 0x3F80000000000000 = reserved bits
+            chunk = table.entries[data_idx] & 0x7FFFFFFFFFFFFF
+            raw_offset = chunk * self.asif.chunk_size
+
+            read_length = min(length, self.asif.chunk_size)
+            if chunk == 0:
+                result.append(b"\x00" * read_length)
+            else:
+                self.asif.fh.seek(raw_offset)
+                result.append(self.asif.fh.read(read_length))
+
+            offset += read_length
+            length -= read_length
+
+        return b"".join(result)

dissect_hypervisor-3.20.dev2/dissect/hypervisor/disk/c_asif.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dissect.cstruct import cstruct
+
+asif_def = """
+#define ASIF_HEADER_SIGNATURE       0x73686477  // 'shdw'
+#define ASIF_META_HEADER_SIGNATURE  0x6D657461  // 'meta'
+
+struct asif_header {
+    uint32  header_signature;
+    uint32  header_version;
+    uint32  header_size;
+    uint32  header_flags;
+    uint64  directory_offsets[2];
+    char    guid[16];
+    uint64  sector_count;
+    uint64  max_sector_count;
+    uint32  chunk_size;
+    uint16  block_size;
+    uint16  total_segments;
+    uint64  metadata_chunk;
+    char    unk_50[16];
+    uint32  read_only_flags;
+    uint32  metadata_flags;
+    uint32  metadata_read_only_flags;
+};
+
+struct asif_meta_header {
+    uint32  header_signature;
+    uint32  header_version;
+    uint32  header_size;
+    uint64  data_size;
+    uint64  unk_14;
+};
+"""
+
+c_asif = cstruct(endian=">").load(asif_def)

dissect_hypervisor-3.20.dev2/dissect/hypervisor/disk/c_asif.pyi

@@ -0,0 +1,68 @@
+# Generated by cstruct-stubgen
+from typing import BinaryIO, Literal, TypeAlias, overload
+
+import dissect.cstruct as __cs__
+
+class _c_asif(__cs__.cstruct):
+    ASIF_HEADER_SIGNATURE: Literal[1936221303] = ...
+    ASIF_META_HEADER_SIGNATURE: Literal[1835365473] = ...
+    class asif_header(__cs__.Structure):
+        header_signature: _c_asif.uint32
+        header_version: _c_asif.uint32
+        header_size: _c_asif.uint32
+        header_flags: _c_asif.uint32
+        directory_offsets: __cs__.Array[_c_asif.uint64]
+        guid: __cs__.CharArray
+        sector_count: _c_asif.uint64
+        max_sector_count: _c_asif.uint64
+        chunk_size: _c_asif.uint32
+        block_size: _c_asif.uint16
+        total_segments: _c_asif.uint16
+        metadata_chunk: _c_asif.uint64
+        unk_50: __cs__.CharArray
+        read_only_flags: _c_asif.uint32
+        metadata_flags: _c_asif.uint32
+        metadata_read_only_flags: _c_asif.uint32
+        @overload
+        def __init__(
+            self,
+            header_signature: _c_asif.uint32 | None = ...,
+            header_version: _c_asif.uint32 | None = ...,
+            header_size: _c_asif.uint32 | None = ...,
+            header_flags: _c_asif.uint32 | None = ...,
+            directory_offsets: __cs__.Array[_c_asif.uint64] | None = ...,
+            guid: __cs__.CharArray | None = ...,
+            sector_count: _c_asif.uint64 | None = ...,
+            max_sector_count: _c_asif.uint64 | None = ...,
+            chunk_size: _c_asif.uint32 | None = ...,
+            block_size: _c_asif.uint16 | None = ...,
+            total_segments: _c_asif.uint16 | None = ...,
+            metadata_chunk: _c_asif.uint64 | None = ...,
+            unk_50: __cs__.CharArray | None = ...,
+            read_only_flags: _c_asif.uint32 | None = ...,
+            metadata_flags: _c_asif.uint32 | None = ...,
+            metadata_read_only_flags: _c_asif.uint32 | None = ...,
+        ): ...
+        @overload
+        def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ...
+
+    class asif_meta_header(__cs__.Structure):
+        header_signature: _c_asif.uint32
+        header_version: _c_asif.uint32
+        header_size: _c_asif.uint32
+        data_size: _c_asif.uint64
+        unk_14: _c_asif.uint64
+        @overload
+        def __init__(
+            self,
+            header_signature: _c_asif.uint32 | None = ...,
+            header_version: _c_asif.uint32 | None = ...,
+            header_size: _c_asif.uint32 | None = ...,
+            data_size: _c_asif.uint64 | None = ...,
+            unk_14: _c_asif.uint64 | None = ...,
+        ): ...
+        @overload
+        def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ...
+
+# Technically `c_asif` is an instance of `_c_asif`, but then we can't use it in type hints
+c_asif: TypeAlias = _c_asif

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect/hypervisor/disk/c_qcow2.pyi

@@ -1,8 +1,7 @@
 # Generated by cstruct-stubgen
-from typing import BinaryIO, Literal, overload
+from typing import BinaryIO, Literal, TypeAlias, overload
 
 import dissect.cstruct as __cs__
-from typing_extensions import TypeAlias
 
 class _c_qcow2(__cs__.cstruct):
     MIN_CLUSTER_BITS: Literal[9] = ...

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect/hypervisor/disk/vhdx.py

@@ -7,7 +7,7 @@ import logging
 import os
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Final
+from typing import TYPE_CHECKING, Any, BinaryIO, Final
 from uuid import UUID
 
 from dissect.util.stream import AlignedStream
@@ -29,7 +29,7 @@ from dissect.hypervisor.disk.c_vhdx import (
 from dissect.hypervisor.exceptions import InvalidSignature, InvalidVirtualDisk
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Callable, Iterator
 
 log = logging.getLogger(__name__)
 log.setLevel(os.getenv("DISSECT_LOG_VHDX", "CRITICAL"))

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect/hypervisor/util/vmtar.py

@@ -62,12 +62,12 @@ class VisorTarFile(tarfile.TarFile):
             raise tarfile.TarError("visor currently only supports read mode")
 
         try:
-            from gzip import GzipFile
+            from gzip import GzipFile  # noqa: PLC0415
         except ImportError:
             raise tarfile.CompressionError("gzip module is not available") from None
 
         try:
-            from lzma import LZMAError, LZMAFile
+            from lzma import LZMAError, LZMAFile  # noqa: PLC0415
         except ImportError:
             raise tarfile.CompressionError("lzma module is not available") from None
 

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect.hypervisor.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: dissect.hypervisor
-Version: 3.19.dev2
+Version: 3.20.dev2
 Summary: A Dissect module implementing parsers for various hypervisor disk, backup and configuration files
 Author-email: Dissect Team <dissect@fox-it.com>
-License: Affero General Public License v3
+License-Expression: AGPL-3.0-or-later
 Project-URL: homepage, https://dissect.tools
 Project-URL: documentation, https://docs.dissect.tools/en/latest/projects/dissect.hypervisor
 Project-URL: repository, https://github.com/fox-it/dissect.hypervisor
@@ -11,14 +11,13 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Internet :: Log Analysis
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Security
 Classifier: Topic :: Utilities
-Requires-Python: ~=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: COPYRIGHT

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/dissect.hypervisor.egg-info/SOURCES.txt

@@ -21,6 +21,9 @@ dissect/hypervisor/descriptor/pvs.py
 dissect/hypervisor/descriptor/vbox.py
 dissect/hypervisor/descriptor/vmx.py
 dissect/hypervisor/disk/__init__.py
+dissect/hypervisor/disk/asif.py
+dissect/hypervisor/disk/c_asif.py
+dissect/hypervisor/disk/c_asif.pyi
 dissect/hypervisor/disk/c_hdd.py
 dissect/hypervisor/disk/c_qcow2.py
 dissect/hypervisor/disk/c_qcow2.pyi
@@ -45,6 +48,7 @@ tests/conftest.py
 tests/_data/descriptor/hyperv/test.VMRS
 tests/_data/descriptor/hyperv/test.vmcx
 tests/_data/descriptor/vmx/encrypted.vmx
+tests/_data/disk/asif/basic.asif.gz
 tests/_data/disk/hdd/expanding.hdd/DiskDescriptor.xml
 tests/_data/disk/hdd/expanding.hdd/expanding.hdd
 tests/_data/disk/hdd/expanding.hdd/expanding.hdd.0.{5fbaabe3-6958-40ff-92a7-860e329aab41}.hds.gz
@@ -85,6 +89,7 @@ tests/descriptor/test_pvs.py
 tests/descriptor/test_vbox.py
 tests/descriptor/test_vmx.py
 tests/disk/__init__.py
+tests/disk/test_asif.py
 tests/disk/test_hdd.py
 tests/disk/test_qcow2.py
 tests/disk/test_vhd.py

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/pyproject.toml

@@ -1,13 +1,14 @@
 [build-system]
-requires = ["setuptools>=65.5.0", "setuptools_scm[toml]>=6.4.0"]
+requires = ["setuptools>=77.0.0", "setuptools_scm[toml]>=6.4.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "dissect.hypervisor"
 description = "A Dissect module implementing parsers for various hypervisor disk, backup and configuration files"
 readme = "README.md"
-requires-python = "~=3.9"
-license.text = "Affero General Public License v3"
+requires-python = ">=3.10"
+license = "AGPL-3.0-or-later"
+license-files = ["LICENSE", "COPYRIGHT"]
 authors = [
   {name = "Dissect Team", email = "dissect@fox-it.com"}
 ]
@@ -16,7 +17,6 @@ classifiers = [
   "Environment :: Console",
   "Intended Audience :: Developers",
   "Intended Audience :: Information Technology",
-  "License :: OSI Approved",
   "Operating System :: OS Independent",
   "Programming Language :: Python :: 3",
   "Topic :: Internet :: Log Analysis",
@@ -46,13 +46,33 @@ dev = [
     "dissect.util>=3.0.dev,<4.0.dev",
 ]
 
+[dependency-groups]
+test = [
+    "pytest",
+]
+lint = [
+    "ruff==0.13.1",
+    "vermin",
+]
+build = [
+    "build",
+]
+debug = [
+    "ipdb",
+]
+dev = [
+    {include-group = "test"},
+    {include-group = "lint"},
+    {include-group = "debug"},
+]
+
 [project.scripts]
 envelope-decrypt = "dissect.hypervisor.tools.envelope:main"
 vmtar = "dissect.hypervisor.tools.vmtar:main"
 
 [tool.ruff]
 line-length = 120
-required-version = ">=0.11.0"
+required-version = ">=0.13.1"
 
 [tool.ruff.format]
 docstring-code-format = true
@@ -102,9 +122,6 @@ ignore = ["E203", "B904", "UP024", "ANN002", "ANN003", "ANN204", "ANN401", "SIM1
 known-first-party = ["dissect.hypervisor"]
 known-third-party = ["dissect"]
 
-[tool.setuptools]
-license-files = ["LICENSE", "COPYRIGHT"]
-
 [tool.setuptools.packages.find]
 include = ["dissect.*"]
 

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/tests/conftest.py

@@ -108,6 +108,11 @@ def snapshot_qcow2() -> Iterator[BinaryIO]:
     yield from open_file_gz("_data/disk/qcow2/snapshot.qcow2.gz")
 
 
+@pytest.fixture
+def basic_asif() -> Iterator[BinaryIO]:
+    yield from open_file_gz("_data/disk/asif/basic.asif.gz")
+
+
 @pytest.fixture
 def envelope() -> Iterator[BinaryIO]:
     yield from open_file("_data/util/envelope/local.tgz.ve")

dissect_hypervisor-3.20.dev2/tests/disk/test_asif.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import BinaryIO
+
+from dissect.hypervisor.disk.asif import ASIF
+
+
+def test_asif(basic_asif: BinaryIO) -> None:
+    """Test ASIF parsing."""
+    asif = ASIF(basic_asif)
+
+    assert asif.internal_metadata == {"stable uuid": "13db9632-b79f-4e95-aada-835d5ef97bba"}
+    assert asif.user_metadata == {}
+
+    with asif.open() as stream:
+        for i in range(100):
+            assert stream.read(1024 * 1024).strip(bytes([i])) == b"", f"Mismatch at offset {i * 1024 * 1024:#x}"

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/tests/disk/test_hdd.py

@@ -61,7 +61,7 @@ def test_split_hdd(split_hdd: Path) -> None:
 
     start = 0
 
-    for storage, split_size in zip(storages, split_sizes):
+    for storage, split_size in zip(storages, split_sizes, strict=False):
         assert storage.start == start
         assert storage.end == start + split_size
         assert len(storage.images) == 1

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/tests/disk/test_qcow2.py

@@ -31,7 +31,7 @@ def test_basic(basic_qcow2: BinaryIO) -> None:
 def test_data_file(data_file_qcow2: Path) -> None:
     # Test with file handle
     with gzip.open(data_file_qcow2, "rb") as fh:
-        with pytest.raises(Error, match="data-file required but not provided \\(image_data_file = 'data-file.bin'\\)"):
+        with pytest.raises(Error, match=r"data-file required but not provided \(image_data_file = 'data-file.bin'\)"):
             QCow2(fh)
 
         with gzip.open(data_file_qcow2.with_name("data-file.bin.gz"), "rb") as fh_bin:
@@ -47,7 +47,7 @@ def test_data_file(data_file_qcow2: Path) -> None:
         # Test with allow_no_data_file
         qcow2 = QCow2(fh, allow_no_data_file=True)
         assert qcow2.data_file is None
-        with pytest.raises(Error, match="data-file required but not provided \\(image_data_file = 'data-file.bin'\\)"):
+        with pytest.raises(Error, match=r"data-file required but not provided \(image_data_file = 'data-file.bin'\)"):
             qcow2.open()
 
     # Test with Path
@@ -68,12 +68,12 @@ def test_backing_file(backing_chain_qcow2: tuple[Path, Path, Path]) -> None:
     # Test with file handle
     with gzip.open(file1, "rb") as fh1, gzip.open(file2, "rb") as fh2, gzip.open(file3, "rb") as fh3:
         with pytest.raises(
-            Error, match="backing-file required but not provided \\(auto_backing_file = 'backing-chain-2.qcow2'\\)"
+            Error, match=r"backing-file required but not provided \(auto_backing_file = 'backing-chain-2.qcow2'\)"
         ):
             QCow2(fh1)
 
         with pytest.raises(
-            Error, match="backing-file required but not provided \\(auto_backing_file = 'backing-chain-3.qcow2'\\)"
+            Error, match=r"backing-file required but not provided \(auto_backing_file = 'backing-chain-3.qcow2'\)"
         ):
             QCow2(fh1, backing_file=fh2)
 
@@ -87,7 +87,7 @@ def test_backing_file(backing_chain_qcow2: tuple[Path, Path, Path]) -> None:
         qcow2 = QCow2(fh1, allow_no_backing_file=True)
         assert qcow2.backing_file is None
         with pytest.raises(
-            Error, match="backing-file required but not provided \\(auto_backing_file = 'backing-chain-2.qcow2'\\)"
+            Error, match=r"backing-file required but not provided \(auto_backing_file = 'backing-chain-2.qcow2'\)"
         ):
             qcow2.open()
 

{dissect_hypervisor-3.19.dev2 → dissect_hypervisor-3.20.dev2}/tox.ini

@@ -4,7 +4,7 @@ envlist = lint, py3, pypy3
 # requires if they are not available on the host system. This requires the
 # locally installed tox to have a minimum version 3.3.0. This means the names
 # of the configuration options are still according to the tox 3.x syntax.
-minversion = 4.4.3
+minversion = 4.27.0
 # This version of virtualenv will install setuptools version 68.2.2 and pip
 # 23.3.1. These versions fully support python projects defined only through a
 # pyproject.toml file (PEP-517/PEP-518/PEP-621). This pip version also support
@@ -14,9 +14,9 @@ requires = virtualenv>=20.24.6
 [testenv]
 extras = dev
 deps =
-    pytest
     pytest-cov
     coverage
+dependency_groups = test
 commands =
     pytest --basetemp="{envtmpdir}" {posargs:--color=yes --cov=dissect --cov-report=term-missing -v tests}
     coverage report
@@ -24,28 +24,24 @@ commands =
 
 [testenv:build]
 package = skip
-deps =
-    build
+dependency_groups = build
 commands =
     pyproject-build
 
 [testenv:fix]
 package = skip
-deps =
-    ruff==0.11.10
+dependency_groups = lint
 commands =
-    ruff format dissect tests
     ruff check --fix dissect tests
+    ruff format dissect tests
 
 [testenv:lint]
 package = skip
-deps =
-    ruff==0.11.10
-    vermin
+dependency_groups = lint
 commands =
-    ruff format --check dissect tests
     ruff check dissect tests
-    vermin -t=3.9- --no-tips --lint dissect tests
+    ruff format --check dissect tests
+    vermin -t=3.10- --no-tips --lint dissect tests
 
 [testenv:docs-build]
 allowlist_externals = make