Patched code sample

import struct

# In a real client, this would be a configurable value, e.g., `max_request_size`.
# We set a reasonable default limit to prevent enormous memory allocations.
MAX_FRAME_SIZE = 100 * 1024 * 1024  # 100MB

def receive_bytes(sock):
    """
    Reads a 4-byte length-prefixed frame from a socket-like object.
    This function represents a fixed version of the vulnerable code.
    """
    # Read the 4-byte frame length prefix.
    size_bytes = sock.read(4)
    if not size_bytes or len(size_bytes) < 4:
        # Not enough data to read size, indicating a closed or broken connection.
        return None

    # Unpack the size as a big-endian 32-bit signed integer.
    (size,) = struct.unpack('>i', size_bytes)

    # --- FIX STARTS HERE ---
    # The vulnerability was the absence of the following two checks.

    # 1. FIX: Disallow negative sizes. A negative value would cause a
    #    ValueError in sock.read(size) and could leave the connection
    #    in a broken, un-reusable state.
    if size < 0:
        raise ValueError(f"Invalid frame size received: {size}. Must be non-negative.")

    # 2. FIX: Enforce a maximum frame size. This prevents a malicious actor
    #    from sending a very large positive number (e.g., 2GB) to trigger
    #    a massive memory allocation, leading to a MemoryError and DoS.
    if size > MAX_FRAME_SIZE:
        raise ValueError(
            f"Frame size {size} exceeds the configured maximum of {MAX_FRAME_SIZE}."
        )
    # --- FIX ENDS HERE ---

    # If the size is valid and within bounds, safely read the payload.
    payload = sock.read(size)

    # It's also good practice to check if the full payload was received.
    if len(payload) < size:
        raise IOError("Connection closed prematurely while reading frame payload.")

    return payload