Patched code sample

# This code represents the principle of the fix for the pyasn1 vulnerability
# (described in CVE-2024-37891, which matches the user's description).
# The vulnerability was addressed in pyasn1 version 0.6.0.

# The vulnerability was caused by a quadratic time complexity (O(n^2)) algorithm
# for decoding Object Identifiers (OIDs), which was based on repeated string
# concatenation. An attacker could provide a small OID with many components
# ("arcs") to cause excessive CPU usage and a denial-of-service.

# The fix replaces the inefficient algorithm with a linear-time (O(n)) one.
# This is achieved by collecting the string representation of each arc into a
# list and then using a single `join` operation to form the final OID string.


def decode_oid_fixed(oid_arcs):
    """
    Decodes a sequence of OID arcs into a dot-separated string representation
    using an efficient, linear-time algorithm that mirrors the pyasn1 fix.

    This approach avoids the quadratic performance bottleneck present in
    vulnerable versions.

    Args:
        oid_arcs: A list or tuple of integers representing the OID's arcs.

    Returns:
        A string representing the OID.
    """
    if not oid_arcs:
        return ""

    # 1. Collect all OID arc components as strings in a list. This is a
    #    linear-time operation.
    components = [str(arc) for arc in oid_arcs]

    # 2. Join the list of strings into a single string. This is also a
    #    linear-time operation, and is the core of the performance fix.
    return ".".join(components)


# --- Demonstration ---
# The following code demonstrates the efficiency of the fixed method.
# With a vulnerable implementation, processing a large number of arcs
# would be extremely slow. With the fix, it is fast.

if __name__ == '__main__':
    # A payload representing an OID with a very large number of arcs,
    # similar to what would be used in a DoS attack.
    # A real attack payload might have 10,000s of arcs.
    malicious_arcs = [1, 3, 6, 1, 4, 1] + list(range(20000))

    print(f"Decoding an OID with {len(malicious_arcs)} arcs using the fixed method...")

    # This call completes quickly, demonstrating the linear-time performance.
    # In a vulnerable version, this would hang or consume 100% CPU for a long time.
    decoded_oid = decode_oid_fixed(malicious_arcs)

    print("Decoding complete.")
    print(f"Result (first 60 chars): {decoded_oid[:60]}...")