Description

IBM Qiskit SDK 2.1.0 through 2.5.1 could allow a local attacker to cause a denial of service due to improper handling of a specially crafted object during deserialization. A malicious QPY payload can trigger a segmentation fault, causing the application to crash when deserializing untrusted input.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "6.2",
  "pubDate": "2026-09-03T20:17:19.790Z",
  "pubdate": "2026-09-03T20:17:19.790Z",
  "executiveSummary": "IBM Qiskit SDK versions 2.1.0 through 2.5.1 contain a vulnerability in the handling of QPY (Qiskit Program format) payloads during the deserialization process. This flaw allows a local attacker to trigger a segmentation fault, resulting in a denial-of-service (DoS) condition.\nThe vulnerability stems from improper validation and memory handling when processing specially crafted, malicious QPY objects. When the SDK attempts to deserialize untrusted input, the malformed structure can lead to undefined behavior in the application's execution environment.\nThe impact is primarily localized to the crashing of the Qiskit process, effectively halting any computational tasks or services utilizing the affected SDK versions. This vulnerability requires local access to the system to submit the crafted payload. Organizations and developers using these versions of Qiskit are at risk if their applications process serialized data from potentially untrusted or external sources. Given the nature of the vulnerability, there is no evidence of remote code execution, but the service disruption could interfere with critical research or production workflows.",
  "technicalDetails": "The vulnerability is located within the QPY serialization/deserialization logic of the IBM Qiskit SDK. The QPY format is used to archive and transfer quantum circuits and associated data. During the deserialization phase, the SDK invokes specific internal routines to reconstruct objects from the serialized byte stream. The root cause of the segmentation fault is a failure to safely validate object integrity and metadata constraints within the QPY file headers or data structures.\nWhen a specially crafted QPY payload is processed, the parser may encounter malformed pointers, invalid object references, or unexpected structure sizes that deviate from the expected protocol schema. Because the deserialization routines operate at a level where memory management must be precise, the processing of an attacker-supplied, non-compliant input forces the application to attempt unauthorized or illegal memory access. This violation is trapped by the operating system's memory protection unit, resulting in a segmentation fault (SIGSEGV).\nThe attack flow follows a deterministic pattern: First, the attacker generates a malicious QPY file that conforms to the expected QPY structure but contains carefully manipulated internal fields that trigger the logical error during decoding. Second, the attacker ensures this file is passed to an application or script that utilizes the vulnerable Qiskit SDK deserialization method (e.g., loading a circuit or experiment). Third, upon invocation of the load or read function, the SDK attempts to process the payload. As the internal parser iterates through the malformed object graph, the corrupted metadata forces a memory-unsafe operation. Finally, the application crashes, effectively terminating the execution of the Qiskit environment.\nThe vulnerability is restricted to versions 2.1.0 through 2.5.1. Authentication and privilege requirements are primarily defined by the local environment; the attacker must have the ability to influence the input processed by the Qiskit library. There is no network exposure inherent to the vulnerability itself, but if an application exposes a web interface or API that accepts file uploads or data blobs for Qiskit processing, the attack vector could be extended to allow for remote service disruption. Post-exploitation, the primary impact remains the immediate and unhandled termination of the process, which can lead to data loss of in-memory quantum circuits or the stalling of automated laboratory or simulation pipelines."
}