dissect.target 3.20.2.dev33__tar.gz → 3.20.2.dev35__tar.gz

{dissect_target-3.20.2.dev33/dissect.target.egg-info → dissect_target-3.20.2.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev33
+Version: 3.20.2.dev35
 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.20.2.dev33 → dissect_target-3.20.2.dev35}/dissect/target/helpers/fsutil.py

@@ -87,6 +87,7 @@ __all__ = [
     "PureDissectPath",
     "relpath",
     "resolve_link",
+    "reverse_read",
     "reverse_readlines",
     "split",
     "splitdrive",
@@ -561,6 +562,29 @@ def open_decompress(
     return file
 
 
+def reverse_read(fh: BinaryIO, chunk_size: int = io.DEFAULT_BUFFER_SIZE, reverse_chunk: bool = True) -> Iterator[bytes]:
+    """Like iterating over chunks of a binary file-like object, but starting from the end of the file.
+
+    Args:
+        fh: The file-like object (opened in binary mode) to read from.
+        chunk_size: The chunk size to use for iterating over bytes (default: 8KB).
+        reverse_chunk: Whether we should reverse the bytes of each chunk (default: True).
+
+    Returns:
+        An iterator of byte chunks, starting from the end of the file-like object and moving to the start.
+    """
+
+    offset = fh.seek(0, io.SEEK_END)
+
+    while offset > 0:
+        if offset < chunk_size:
+            chunk_size = offset
+        offset -= chunk_size
+        fh.seek(offset)
+        buf = fh.read(chunk_size)
+        yield bytes(reversed(buf)) if reverse_chunk else buf
+
+
 def reverse_readlines(fh: TextIO, chunk_size: int = 1024 * 1024 * 8) -> Iterator[str]:
     """Like iterating over a ``TextIO`` file-like object, but starting from the end of the file.
 

dissect_target-3.20.2.dev35/dissect/target/helpers/nfs/client.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from contextlib import AbstractContextManager
+from typing import TYPE_CHECKING, Generic, Iterator, NamedTuple, TypeVar
+
+from dissect.target.helpers.nfs.nfs3 import (
+    CookieVerf3,
+    EntryPlus3,
+    FileAttributes3,
+    FileHandle3,
+    Nfs3Stat,
+    Read3args,
+    ReadDirPlusParams,
+    ReadDirPlusProc,
+    ReadFileProc,
+)
+from dissect.target.helpers.nfs.serializer import (
+    Read3ArgsSerializer,
+    Read3ResultDeserializer,
+    ReadDirPlusParamsSerializer,
+    ReadDirPlusResultDeserializer,
+)
+from dissect.target.helpers.sunrpc.client import AuthScheme
+from dissect.target.helpers.sunrpc.client import Client as SunRpcClient
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+Credentials = TypeVar("Credentials")
+Verifier = TypeVar("Verifier")
+
+
+class ReadFileError(Exception):
+    pass
+
+
+class ReadDirResult(NamedTuple):
+    dir_attributes: FileAttributes3 | None
+    entries: list[EntryPlus3]
+
+
+# RdJ Bit annoying that the Credentials and Verifier keep propagating as type parameters of the class.
+# Alternatively, we could use type erasure and couple the auth data with the auth serializer,
+# and make the auth data in the `CallBody` class opaque.
+class Client(AbstractContextManager, Generic[Credentials, Verifier]):
+    DIR_COUNT = 4096  # See https://datatracker.ietf.org/doc/html/rfc1813#section-3.3.17
+    MAX_COUNT = 32768
+    READ_CHUNK_SIZE = 1024 * 1024
+
+    def __init__(self, rpc_client: SunRpcClient[Credentials, Verifier]):
+        self._rpc_client = rpc_client
+
+    def __exit__(self, _: type[BaseException] | None, __: BaseException | None, ___: TracebackType | None) -> bool:
+        self._rpc_client.close()
+        return False  # Reraise exceptions
+
+    @classmethod
+    def connect(cls, hostname: str, port: int, auth: AuthScheme[Credentials, Verifier], local_port: int) -> Client:
+        rpc_client = SunRpcClient.connect(hostname, port, auth, local_port)
+        return Client(rpc_client)
+
+    def readdirplus(self, dir: FileHandle3) -> ReadDirResult | Nfs3Stat:
+        """Read the contents of a directory, including file attributes"""
+
+        entries = list[EntryPlus3]()
+        cookie = 0
+        cookieverf = CookieVerf3(b"\x00")
+
+        # Multiple calls might be needed to read the entire directory
+        while True:
+            params = ReadDirPlusParams(dir, cookie, cookieverf, dir_count=self.DIR_COUNT, max_count=self.MAX_COUNT)
+            result = self._rpc_client.call(
+                ReadDirPlusProc, params, ReadDirPlusParamsSerializer(), ReadDirPlusResultDeserializer()
+            )
+            if isinstance(result, Nfs3Stat):
+                return result
+
+            entries += result.entries
+            if result.eof or len(result.entries) == 0:
+                return ReadDirResult(result.dir_attributes, entries)
+
+            cookie = result.entries[-1].cookie
+            cookieverf = result.cookieverf
+
+    def readfile_by_handle(self, handle: FileHandle3) -> Iterator[bytes]:
+        """Read a file by its file handle"""
+        offset = 0
+        count = self.READ_CHUNK_SIZE
+        while True:
+            params = Read3args(handle, offset, count)
+            result = self._rpc_client.call(ReadFileProc, params, Read3ArgsSerializer(), Read3ResultDeserializer())
+            if isinstance(result, Nfs3Stat):
+                raise ReadFileError(f"Failed to read file: {result}")
+            yield result.data
+            if result.eof:
+                return
+            offset += result.count

dissect_target-3.20.2.dev35/dissect/target/helpers/nfs/demo.py

@@ -0,0 +1,62 @@
+import argparse
+
+from dissect.target.helpers.nfs.client import Client as NfsClient
+from dissect.target.helpers.nfs.nfs3 import EntryPlus3, GetPortProc, MountOK, MountProc
+from dissect.target.helpers.nfs.serializer import MountResultDeserializer
+from dissect.target.helpers.sunrpc.client import Client, auth_null, auth_unix
+from dissect.target.helpers.sunrpc.serializer import (
+    PortMappingSerializer,
+    StringSerializer,
+    UInt32Serializer,
+)
+from dissect.target.helpers.sunrpc.sunrpc import PortMapping, Protocol
+
+NFS_PROGRAM = 100003
+NFS_V3 = 3
+
+
+# NFS client demo, showing how to connect to an NFS server and list the contents of a directory
+# Note: some nfs servers require connecting using a low port number (use --port)
+def main():
+    parser = argparse.ArgumentParser(description="NFS Client")
+    parser.add_argument("root", type=str, help="The root directory to mount")
+    parser.add_argument("--hostname", type=str, default="localhost", help="The hostname of the NFS server")
+    parser.add_argument("--port", type=int, default=0, help="The local port to bind to (default: 0)")
+    parser.add_argument("--uid", type=int, default=1000, help="The user id to use for authentication")
+    parser.add_argument("--gid", type=int, default=1000, help="The group id to use for authentication")
+    parser.add_argument("--index", type=int, default=-1, help="The index of the file to read (starting at 1)")
+    args = parser.parse_args()
+
+    # RdJ: Perhaps move portmapper to nfs client and cache the mapping
+    with Client.connect_port_mapper(args.hostname) as port_mapper_client:
+        params_mount = PortMapping(program=MountProc.program, version=MountProc.version, protocol=Protocol.TCP)
+        mount_port = port_mapper_client.call(GetPortProc, params_mount, PortMappingSerializer(), UInt32Serializer())
+        params_nfs = PortMapping(program=NFS_PROGRAM, version=NFS_V3, protocol=Protocol.TCP)
+        nfs_port = port_mapper_client.call(GetPortProc, params_nfs, PortMappingSerializer(), UInt32Serializer())
+
+    # RdJ: Encapsualte in dedicated mount client? Or move to nfs client.
+    with Client.connect(args.hostname, mount_port, auth_null(), args.port) as mount_client:
+        mount_result = mount_client.call(MountProc, args.root, StringSerializer(), MountResultDeserializer())
+        if not isinstance(mount_result, MountOK):
+            print(f"Failed to mount {args.root} with error code {mount_result}")
+            return
+
+    auth = auth_unix("twigtop", args.uid, args.gid, [])
+    with NfsClient.connect(args.hostname, nfs_port, auth, args.port) as nfs_client:
+        readdir_result = nfs_client.readdirplus(mount_result.filehandle)
+        for index, entry in enumerate(readdir_result.entries, start=1):
+            if entry.attributes:
+                print(f"{index:<5} {entry.name:<30} {entry.attributes.size:<10}")
+
+        if args.index < 0:
+            return
+        file_entry: EntryPlus3 = readdir_result.entries[args.index - 1]
+        if file_entry.attributes:
+            file_contents = nfs_client.readfile_by_handle(file_entry.handle)
+            with open(file_entry.name, "wb") as f:
+                for chunk in file_contents:
+                    f.write(chunk)
+
+
+if __name__ == "__main__":
+    main()

dissect_target-3.20.2.dev35/dissect/target/helpers/nfs/nfs3.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import ClassVar, NamedTuple
+
+# See https://datatracker.ietf.org/doc/html/rfc1057
+
+
+class ProcedureDescriptor(NamedTuple):
+    program: int
+    version: int
+    procedure: int
+
+
+# List of procedure descriptors
+GetPortProc = ProcedureDescriptor(100000, 2, 3)
+MountProc = ProcedureDescriptor(100005, 3, 1)
+ReadDirPlusProc = ProcedureDescriptor(100003, 3, 17)
+ReadFileProc = ProcedureDescriptor(100003, 3, 6)
+
+
+class Nfs3Stat(IntEnum):
+    OK = 0
+    ERR_PERM = 1
+    ERR_NOENT = 2
+    ERR_IO = 5
+    ERR_NXIO = 6
+    ERR_ACCES = 13
+    ERR_EXIST = 17
+    ERR_XDEV = 18
+    ERR_NODEV = 19
+    ERR_NOTDIR = 20
+    ERR_ISDIR = 21
+    ERR_INVAL = 22
+    ERR_FBIG = 27
+    ERR_NOSPC = 28
+    ERR_ROFS = 30
+    ERR_MLINK = 31
+    ERR_NAMETOOLONG = 63
+    ERR_NOTEMPTY = 66
+    ERR_DQUOT = 69
+    ERR_STALE = 70
+    ERR_REMOTE = 71
+    ERR_BADHANDLE = 10001
+
+
+@dataclass
+class FileHandle3:
+    MAXSIZE: ClassVar[int] = 64
+    opaque: bytes
+
+    def __post_init__(self):
+        if len(self.opaque) > self.MAXSIZE:
+            raise ValueError(f"FileHandle3 cannot exceed {self.MAXSIZE} bytes")
+
+
+@dataclass
+class CookieVerf3:
+    MAXSIZE: ClassVar[int] = 8
+    opaque: bytes
+
+    def __post_init__(self):
+        if len(self.opaque) > self.MAXSIZE:
+            raise ValueError(f"CookieVerf cannot exceed {self.MAXSIZE} bytes")
+
+
+class FileType3(IntEnum):
+    REG = 1  # regular file
+    DIR = 2  # directory
+    BLK = 3  # block special
+    CHR = 4  # character special
+    LNK = 5  # symbolic link
+    SOCK = 6  # socket
+    FIFO = 7  # fifo
+
+
+@dataclass
+class SpecData3:
+    specdata1: int
+    specdata2: int
+
+
+@dataclass
+class NfsTime3:
+    seconds: int
+    nseconds: int
+
+
+@dataclass
+class FileAttributes3:
+    type: FileType3
+    mode: int
+    nlink: int
+    uid: int
+    gid: int
+    size: int
+    used: int
+    rdev: SpecData3
+    fsid: int
+    fileid: int
+    atime: NfsTime3
+    mtime: NfsTime3
+    ctime: NfsTime3
+
+
+class MountStat3(IntEnum):
+    OK = 0  # no error
+    ERR_PERM = 1  # Not owner
+    ERR_NOENT = 2  # No such file or directory
+    ERR_IO = 5  # I/O error
+    ERR_ACCES = 13  # Permission denied
+    ERR_NOTDIR = 20  # Not a directory
+    ERR_INVAL = 22  # Invalid argument
+    ERR_NAMETOOLONG = 63  # Filename too long
+    ERR_NOTSUPP = 10004  # Operation not supported
+    ERR_SERVERFAULT = 10006  # A failure on the server
+
+
+@dataclass
+class MountParams:
+    dirpath: str
+
+
+@dataclass
+class MountOK:
+    filehandle: FileHandle3
+    auth_flavors: list[int]
+
+
+@dataclass
+class ReadDirPlusParams:
+    dir: FileHandle3
+    cookie: int
+    cookieverf: CookieVerf3
+    dir_count: int
+    max_count: int
+
+
+@dataclass
+class EntryPlus3:
+    fileid: int
+    name: str
+    cookie: int
+    attributes: FileAttributes3 | None
+    handle: FileHandle3 | None
+
+
+@dataclass
+class ReadDirPlusResult3:
+    dir_attributes: FileAttributes3 | None
+    cookieverf: CookieVerf3
+    entries: list[EntryPlus3]
+    eof: bool
+
+
+@dataclass
+class Read3args:
+    file: FileHandle3
+    offset: int
+    count: int
+
+
+@dataclass
+class Read3resok:
+    file_attributes: FileAttributes3 | None
+    count: int
+    eof: bool
+    data: bytes

dissect_target-3.20.2.dev35/dissect/target/helpers/nfs/serializer.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import io
+from typing import Union
+
+from dissect.target.helpers.nfs.nfs3 import (
+    CookieVerf3,
+    EntryPlus3,
+    FileAttributes3,
+    FileHandle3,
+    FileType3,
+    MountOK,
+    MountStat3,
+    Nfs3Stat,
+    NfsTime3,
+    Read3args,
+    Read3resok,
+    ReadDirPlusParams,
+    ReadDirPlusResult3,
+    SpecData3,
+)
+from dissect.target.helpers.sunrpc.serializer import (
+    Int32Serializer,
+    OpaqueVarLengthSerializer,
+    XdrDeserializer,
+    XdrSerializer,
+)
+from dissect.target.helpers.sunrpc.sunrpc import Bool
+
+
+# Used Union because 3.9 does not support '|' here even with future annotations
+class MountResultDeserializer(XdrDeserializer[Union[MountOK, MountStat3]]):
+    def deserialize(self, payload: io.BytesIO) -> MountOK | MountStat3:
+        mount_stat = self._read_enum(payload, MountStat3)
+        if mount_stat != MountStat3.OK:
+            return mount_stat
+        filehandle_bytes = self._read_var_length_opaque(payload)
+        auth_flavors = self._read_var_length(payload, Int32Serializer())
+
+        return MountOK(FileHandle3(filehandle_bytes), auth_flavors)
+
+
+class ReadDirPlusParamsSerializer(XdrSerializer[ReadDirPlusParams]):
+    def serialize(self, params: ReadDirPlusParams) -> bytes:
+        result = self._write_var_length_opaque(params.dir.opaque)
+        result += self._write_uint64(params.cookie)
+        result += self._write_var_length_opaque(params.cookieverf.opaque)
+        result += self._write_uint32(params.dir_count)
+        result += self._write_uint32(params.max_count)
+
+        return result
+
+
+class SpecDataSerializer(XdrDeserializer[SpecData3]):
+    def deserialize(self, payload: io.BytesIO) -> bytes:
+        specdata1 = self._read_uint32(payload)
+        specdata2 = self._read_uint32(payload)
+
+        return SpecData3(specdata1, specdata2)
+
+
+class NfsTimeSerializer(XdrDeserializer[NfsTime3]):
+    def deserialize(self, payload: io.BytesIO) -> bytes:
+        seconds = self._read_uint32(payload)
+        nseconds = self._read_uint32(payload)
+
+        return NfsTime3(seconds, nseconds)
+
+
+class FileAttributesSerializer(XdrDeserializer[FileAttributes3]):
+    def deserialize(self, payload: io.BytesIO) -> FileAttributes3:
+        type = self._read_enum(payload, FileType3)
+        mode = self._read_uint32(payload)
+        nlink = self._read_uint32(payload)
+        uid = self._read_uint32(payload)
+        gid = self._read_uint32(payload)
+        size = self._read_uint64(payload)
+        used = self._read_uint64(payload)
+        rdev = SpecDataSerializer().deserialize(payload)
+        fsid = self._read_uint64(payload)
+        fileid = self._read_uint64(payload)
+        time_deserializer = NfsTimeSerializer()
+        atime = time_deserializer.deserialize(payload)
+        mtime = time_deserializer.deserialize(payload)
+        ctime = time_deserializer.deserialize(payload)
+
+        return FileAttributes3(type, mode, nlink, uid, gid, size, used, rdev, fsid, fileid, atime, mtime, ctime)
+
+
+class EntryPlusSerializer(XdrDeserializer[EntryPlus3]):
+    def deserialize(self, payload: io.BytesIO) -> EntryPlus3:
+        fileid = self._read_uint64(payload)
+        name = self._read_string(payload)
+        cookie = self._read_uint64(payload)
+        attributes = self._read_optional(payload, FileAttributesSerializer())
+        handle_bytes = self._read_optional(payload, OpaqueVarLengthSerializer())
+        handle = FileHandle3(handle_bytes) if handle_bytes is not None else None
+
+        return EntryPlus3(fileid, name, cookie, attributes, handle)
+
+
+# Used Union because 3.9 does not support '|' here even with future annotations
+class ReadDirPlusResultDeserializer(XdrDeserializer[Union[ReadDirPlusResult3, Nfs3Stat]]):
+    def deserialize(self, payload: io.BytesIO) -> ReadDirPlusResult3:
+        stat = self._read_enum(payload, Nfs3Stat)
+        if stat != Nfs3Stat.OK:
+            return stat
+
+        dir_attributes = self._read_optional(payload, FileAttributesSerializer())
+        cookieverf = self._read_var_length_opaque(payload)
+
+        entries = list[EntryPlus3]()
+        while True:
+            entry = self._read_optional(payload, EntryPlusSerializer())
+            if entry is None:
+                break
+
+            entries.append(entry)
+
+        eof = self._read_enum(payload, Bool) == Bool.TRUE
+
+        return ReadDirPlusResult3(dir_attributes, CookieVerf3(cookieverf), entries, eof)
+
+
+class Read3ArgsSerializer(XdrSerializer[ReadDirPlusParams]):
+    def serialize(self, args: Read3args) -> bytes:
+        result = self._write_var_length_opaque(args.file.opaque)
+        result += self._write_uint64(args.offset)
+        result += self._write_uint32(args.count)
+        return result
+
+
+class Read3ResultDeserializer(XdrDeserializer[Read3resok]):
+    def deserialize(self, payload: io.BytesIO) -> Read3resok:
+        stat = self._read_enum(payload, Nfs3Stat)
+        if stat != Nfs3Stat.OK:
+            return stat
+
+        file_attributes = self._read_optional(payload, FileAttributesSerializer())
+        count = self._read_uint32(payload)
+        eof = self._read_enum(payload, Bool) == Bool.TRUE
+        data = self._read_var_length_opaque(payload)
+        return Read3resok(file_attributes, count, eof, data)

dissect_target-3.20.2.dev35/dissect/target/helpers/sunrpc/client.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import random
+import socket
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from dissect.target.helpers.sunrpc import sunrpc
+from dissect.target.helpers.sunrpc.serializer import (
+    AuthNullSerializer,
+    AuthSerializer,
+    AuthUnixSerializer,
+    MessageSerializer,
+    XdrDeserializer,
+    XdrSerializer,
+)
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from dissect.target.helpers.nfs.nfs3 import ProcedureDescriptor
+
+
+Credentials = TypeVar("Credentials")
+Verifier = TypeVar("Verifier")
+Params = TypeVar("Params")
+Results = TypeVar("Results")
+
+
+@dataclass
+class AuthScheme(Generic[Credentials, Verifier]):
+    credentials: Credentials
+    verifier: Verifier
+    credentials_serializer: AuthSerializer[Credentials]
+    verifier_serializer: AuthSerializer[Verifier]
+
+
+def auth_null() -> AuthScheme[sunrpc.AuthNull, sunrpc.AuthNull]:
+    return AuthScheme(sunrpc.AuthNull(), sunrpc.AuthNull(), AuthNullSerializer(), AuthNullSerializer())
+
+
+def auth_unix(machine: str | None, uid: int, gid: int, gids: list[int]) -> AuthScheme[sunrpc.AuthUnix, sunrpc.AuthNull]:
+    stamp = random.randint(0, 2**32 - 1)
+
+    if machine is None:
+        machine = "dissect"
+
+    return AuthScheme(
+        sunrpc.AuthUnix(stamp, machine, uid, gid, gids),
+        sunrpc.AuthNull(),
+        AuthUnixSerializer(),
+        AuthNullSerializer(),
+    )
+
+
+# RdJ: Error handing is a bit minimalistic. Expand later on.
+class MismatchXidError(Exception):
+    pass
+
+
+class UnexpectedResponse(Exception):
+    pass
+
+
+class IncompleteMessage(Exception):
+    pass
+
+
+class Client(AbstractContextManager, Generic[Credentials, Verifier]):
+    PMAP_PORT = 111
+
+    @classmethod
+    def connect_port_mapper(cls, hostname: str) -> Client:
+        return cls.connect(hostname, cls.PMAP_PORT, auth_null())
+
+    @classmethod
+    def connect(cls, hostname: str, port: int, auth: AuthScheme[Credentials, Verifier], local_port: int = 0) -> Client:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(("", local_port))
+        sock.connect((hostname, port))
+
+        return Client(sock, auth)
+
+    def __init__(self, sock: socket.socket, auth: AuthScheme[Credentials, Verifier], fragment_size: int = 8192):
+        self._sock = sock
+        self._auth = auth
+        self._fragment_size = fragment_size
+        self._xid = 1
+
+    def __exit__(self, _: type[BaseException] | None, __: BaseException | None, ___: TracebackType | None) -> bool:
+        self.close()
+        return False  # Reraise exceptions
+
+    def close(self) -> None:
+        try:
+            self._sock.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass  # Ignore errors if the socket is already closed
+        self._sock.close()
+
+    def call(
+        self,
+        proc_desc: ProcedureDescriptor,
+        params: Params,
+        params_serializer: XdrSerializer[Params],
+        result_deserializer: XdrDeserializer[Results],
+    ) -> Results:
+        """Synchronously call an RPC procedure and return the result"""
+
+        call_body = sunrpc.CallBody(
+            proc_desc.program,
+            proc_desc.version,
+            proc_desc.procedure,
+            self._auth.credentials,
+            self._auth.verifier,
+            params,
+        )
+        message = sunrpc.Message(self._xid, call_body)
+        message_serializer = MessageSerializer(
+            params_serializer, result_deserializer, self._auth.credentials_serializer, self._auth.verifier_serializer
+        )
+        request_payload = message_serializer.serialize(message)
+        self._send(request_payload)
+
+        response_payload = self._receive()
+        response = message_serializer.deserialize_from_bytes(response_payload)
+        if response.xid != self._xid:
+            raise MismatchXidError("Invalid response xid")
+        if not isinstance(response.body, sunrpc.AcceptedReply):
+            raise UnexpectedResponse("Unexpected response type")
+        if response.body.stat != sunrpc.AcceptStat.SUCCESS:
+            raise UnexpectedResponse("Call failed")
+
+        self._xid += 1
+        return response.body.results
+
+    def _send(self, data: bytes) -> None:
+        data_size = len(data)
+        offset = 0
+
+        # Messages are split into fragments: 4 bytes for the fragment size, followed by the fragment data
+        while offset < data_size:
+            fragment = data[offset : offset + self._fragment_size]
+            fragment_size = len(fragment)
+
+            fragment_header = fragment_size
+            if offset + fragment_size == data_size:
+                fragment_header = fragment_header | 0x80000000  # MSB set to indicate last fragment
+
+            chunk = fragment_header.to_bytes(4, "big") + fragment
+            self._sock.sendall(chunk)
+            offset += fragment_size
+
+    def _receive(self) -> bytes:
+        fragments = []
+
+        while True:
+            header = self._sock.recv(4)
+            if not header:
+                raise IncompleteMessage("Expected a fragment header")
+
+            fragment_header = int.from_bytes(header, "big")
+            fragment_size = fragment_header & 0x7FFFFFFF
+            while fragment_size > 0:
+                fragment = self._sock.recv(fragment_size)
+                fragments.append(fragment)
+                fragment_size -= len(fragment)
+
+            # Check for last fragment
+            if fragment_header & 0x80000000:
+                return b"".join(fragments)
+
+    def __del__(self):
+        self._sock.close()