⚛️ quantum physics

Broken Quantum: A Systematic Formal Verification Study of Security Vulnerabilities Across the Open-Source Quantum Computing Simulator Ecosystem

Het paper "Broken Quantum" presenteert de eerste uitgebreide formele beveiligingsaudit van de open-source quantum-simulatoren, waarbij met behulp van de COBALT QAI-engine en de Z3-oplosser 547 kwetsbaarheden in 45 frameworks werden geïdentificeerd, waaronder een nieuw quantum-specifiek aanvalsvector genaamd QASM-injectie.

Oorspronkelijke auteurs: Dominik Blain

Gepubliceerd 2026-04-09

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Dominik Blain

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

De "Gebroken Quantum" Rapport: Een Veiligheidscheck van de Quantum-Wereld

Stel je voor dat quantumcomputers de nieuwe raketten zijn die de wetenschap naar de maan willen sturen. Maar voordat je die raketten echt lanceert, moet je ze eerst bouwen en testen in een enorme, complexe simulatie op gewone computers. Dit is wat quantum-simulatoren doen: ze zijn de digitale zandbakken waar wetenschappers, bedrijven en overheden hun quantum-ideeën testen.

In dit rapport, getiteld "Broken Quantum", heeft onderzoeker Dominik Blain een gigantische veiligheidscheck gedaan van 45 van deze digitale zandbakken. Hij keek naar software van grote namen zoals IBM, Google, Amazon, maar ook van universiteiten als Harvard en MIT.

Het resultaat? De meeste van deze zandbakken hebben grote gaten in hun hekwerk. Hier is wat hij ontdekte, vertaald naar begrijpelijke taal:

1. Het Kernprobleem: De "Explosieve" Groei

Het grootste probleem zit in de natuurkunde zelf. Een quantum-computer met maar één extra qubit (een stukje data) verdubbelt de hoeveelheid rekenkracht die nodig is.

De Analogie: Stel je voor dat je een kamer hebt. Als je 1 persoon toevoegt, heb je ruimte voor 2 mensen. Als je 2 toevoegt, heb je ruimte voor 4. Bij 10 mensen heb je ruimte voor 1024. Bij 50 mensen heb je ruimte nodig voor 8 biljoen mensen.
Het Gevaar: De software van deze simulatoren kijkt vaak niet goed naar hoeveel mensen er in de kamer gaan. Als een hacker zegt: "Ik wil een simulatie met 50 qubits", probeert de computer plotseling ruimte te maken voor 8 biljoen mensen. De computer crasht, of in het ergste geval, breekt de software open.

2. De Vier Soorten "Gaten" in het Hek

De onderzoeker vond vier soorten veiligheidslekken:

Type 1: De "Breekbare Muur" (C++ Software)
Sommige programma's zijn gebouwd met een taal die heel snel is, maar ook heel streng (C++). Als je daar te veel mensen in de kamer probeert te stoppen, breekt de muur letterlijk. De software probeert naar een plek in het geheugen te kijken die niet bestaat.
- Voorbeeld: IBM's software en die van het Amerikaanse Oak Ridge Nationaal Laboratorium (een plek waar ze aan kernenergie en quantum werken) hebben dit probleem. Het is alsof een nationale beveiligingsinstallatie een deur heeft die openbreekt als je er te hard tegenaan duwt.
Type 2: De "Uitputting" (Python Software)
Andere programma's zijn gebouwd met een taal die flexibeler is (Python). Hier breekt de muur niet, maar de computer probeert wel om die 8 biljoen mensen te huisvesten. De computer krijgt geen lucht meer, de geheugenbank loopt vol en het systeem crasht.
- Gevolg: Dit is een manier om een dienst plat te leggen (een "Denial of Service" aanval). Als iemand dit doet op een cloud-dienst van Google of Amazon, kunnen echte wetenschappers hun werk niet meer doen.
Type 3: De "Vergiftigde Gift" (Onveilig Laden)
Quantum-wetenschappers slaan hun berekeningen vaak op in bestanden om ze later te openen. Sommige programma's openen deze bestanden zonder te controleren of ze veilig zijn.
- De Analogie: Het is alsof je een pakketje van een onbekende krijgt en het direct opent zonder te kijken wat erin zit. In dit geval zit er een virus in dat de computer overneemt.
- Gevolg: Harvard's software ("tequila") heeft dit probleem. Een hacker kan een speciaal bestand sturen dat, zodra het wordt geopend, de computer van de gebruiker overneemt.
Type 4: De "Quantum-Injectie" (Nieuw en Gevaarlijk)
Dit is een heel nieuw soort probleem dat alleen in de quantum-wereld bestaat. Quantum-computers praten een speciale taal (QASM). Sommige programma's accepteren deze taal zonder te controleren of er "verkeerde zinnen" in staan.
- De Analogie: Het is alsof je een robot een opdracht geeft: "Loop naar de deur". Maar de hacker voegt toe: "En open de deur, en steek de bank in brand". De robot doet alles wat er staat, ook de gevaarlijke delen.

3. De "Kopieerfout" (Supply Chain)

Een van de meest opvallende ontdekkingen is hoe fouten zich verspreiden.

Het verhaal: Het Amerikaanse Oak Ridge Nationaal Laboratorium (een zeer belangrijke overheidsinstelling) gebruikte de software van IBM, maar kopieerde de hele code letterlijk over in hun eigen systeem.
Het gevolg: Omdat IBM een fout in hun code had, had Oak Ridge die fout ook, zonder dat ze het wisten. Het is alsof een fabriek een auto bouwt die een gebrekkige rem heeft, en een andere fabriek die exact dezelfde auto bouwt, vergeet de rem te repareren. Nu hebben twee grote organisaties hetzelfde gevaar.

4. De Scorebord

De onderzoeker gaf een cijfer aan 45 verschillende softwarepakketten:

0/100 (Gebroken): Bekende namen zoals IBM (Qiskit), Google (Cirq), en Harvard (tequila) scoorden het laagst. Ze hebben te veel gaten.
100/100 (Veilig): Een paar kleinere, maar slimme projecten (zoals die van ETH Zürich en Fujitsu) hadden geen gaten. Dit bewijst dat het probleem oplosbaar is; het is gewoon een gebrek aan voorzichtigheid bij de grotere spelers.

5. Wat moet er gebeuren?

De boodschap is niet dat quantumcomputing gevaarlijk is, maar dat de ondergrondse software (de fundamenten) nog te zwak is.

De oplossing: De software moet een "deurwachter" hebben die telt hoeveel mensen er de kamer in willen. Als het aantal te hoog is (bijvoorbeeld meer dan 32 qubits), moet de deur dicht blijven en moet er een waarschuwing komen.
Actie: De onderzoeker heeft de fouten al gemeld aan de bedrijven en universiteiten. Ze werken samen om de gaten te dichten voordat hackers ze kunnen vinden.

Kortom: De quantum-revolutie is op komst, maar de digitale bouwplaatsen waar we aan werken, zijn nog niet veilig genoeg. Dit rapport is een noodkreet om de bouwvakkers te vertellen: "Controleer eerst je fundamenten voordat je de wolkenkrabber bouwt."

Titel: Broken Quantum: Een Systematische Formele Verificatiestudie van Beveiligingskwetsbaarheden in het Open-Source Ecosysteem voor Quantum Computing Simulatoren

Auteur: Dominik Blain (QreativeLab)
Datum: 8 april 2026

1. Het Probleem

Quantum computing-simulatoren vormen de klassieke softwarebasis waarop vrijwel al het onderzoek naar quantum-algoritmen rust. Ondanks hun kritieke rol in de wetenschappelijke infrastructuur van overheden, universiteiten en bedrijven wereldwijd, is de klassieke beveiliging van hun implementaties nooit systematisch onderzocht.

De kern van het probleem ligt in de fundamentele aard van quantum-simulatie: een systeem met $n$ qubits vereist $2^n$ klassieke resources (amplitudes, kansen of matrixelementen). Deze exponentiële schaling is onvermijdelijk voor de nauwkeurigheid van simulaties, maar creëert een kwetsbaarheidspad wanneer gebruikersgestuurde invoer (het aantal qubits) direct leidt tot allocatie van $2^n$ resources zonder validatie. Dit resulteert in:

C++-backends: Geheugenbeschadiging en ongedefinieerd gedrag door integer overflow en out-of-bounds array-toegang.
Python-backends: Onbeperkte verbruik van resources (geheugen/CPU), wat leidt tot Denial-of-Service (DoS).
Seriatie: Onveilige deserialisatie die leidt tot Remote Code Execution (RCE).

2. Methodologie

De auteurs hebben Broken Quantum ontwikkeld, de eerste uitgebreide formele beveiligingsaudit van het open-source ecosysteem.

Omvang: Analyse van 45 open-source quantum-simulatieframeworks van 22 organisaties in 12 landen (waaronder IBM, Google, Amazon, NVIDIA, CERN, Harvard, MIT, Baidu, Tencent, etc.).
Tooling: Toepassing van COBALT QAI, een statische analyse-engine met vier modules, ondersteund door de Z3 SMT-solver (Satisfiability Modulo Theories).
Proces:
1. Patroon-scanning: Regulaire expressies voor bekende kwetsbaarheidspatronen (CWE).
2. Formele verificatie: Elke gevonden kandidaat-kwetsbaarheid wordt geëncodeerd als een bitvector-aritmetische beperking. Een SAT-resultaat (satisfiable) met een concreet bewijs (witness) bevestigt formele bereikbaarheid van de kwetsbaarheid.
Scoring: Frameworks krijgen een score van 0/100 ("Broken") tot 100/100 ("Secure") op basis van het aantal gevonden kritieke, hoge en middelhoge kwetsbaarheden.

3. Belangrijkste Bijdragen

Eerste Ecosysteem-audit: De grootste formele beveiligingsanalyse van quantum-software tot nu toe, dekkend 45 frameworks.
Vier Kwetsbaarheidsklassen: Identificatie van vier specifieke klassen, waaronder een nieuwe, quantum-specifieke klasse.
Formele Bewijzen: 13/13 kwetsbaarheidspatronen formeel geverifieerd via Z3 SAT-proofs.
Supply Chain Ontdekking: Het eerste gedocumenteerde geval van kwetsbaarheidsoverdracht van een commercieel framework (IBM) naar de infrastructuur van een Amerikaanse nationale laboratorium (Oak Ridge NL) via code-vendoring.
Live PoC: Demonstratie van werkende exploits voor DoS, RCE en integer-overflow ketens.
Open Source Tools: Release van de COBALT QAI-scanners voor continue beveiligingsanalyse.

4. Resultaten en Kwetsbaarheidsklassen

De studie identificeerde 547 beveiligingsvondsten (40 CRITICAL, 492 HIGH, 15 MEDIUM). 80% van de onderzochte frameworks (36 van de 45) vertoonde ten minste één kwetsbaarheid.

Klasse I: C++ Geheugenbeschadiging (CWE-125/CWE-190)

Oorzaak: In C++ backends (o.a. Qiskit Aer, XACC) leiden ongeldige qubit-aantallen tot out-of-bounds array-toegang of integer overflow.
Voorbeeld: In Qiskit Aer wordt een vast array BITS[64] gebruikt. Bij num_qubits >= 64 treedt ongedefinieerd gedrag op.
De "32-qubit Grens": Een formele drempel waarbij $n < 64$ maar $2n \ge 64$ (bij $n=32$ ). Dit veroorzaakt overflow in unitary-matrix simulaties die het qubit-aantal verdubbelen.
Impact: 12 CRITICAL bevindingen. Qiskit Aer en XACC scoorden 0/100.

Klasse II: Python Resource Uitputting (CWE-400)

Oorzaak: In Python backends (14 frameworks) wordt np.zeros(2**num_qubits) aangeroepen zonder bovengrens.
Impact: Een aanvaller kan een simpele API-aanroep doen met een groot aantal qubits (bijv. 50), wat leidt tot het proberen alloceren van petabytes aan geheugen of dagenlange CPU-uitputting.
Resultaat: 167 HIGH bevindingen. Frameworks zoals Cirq, PennyLane en qibo scoorden 0/100.

Klasse III: Onveilige Deserialisatie en Code Injectie (CWE-502/CWE-94)

Oorzaak: Gebruik van pickle.load(), eval() of torch.load() zonder validatie bij het laden van geserialiseerde quantum-circuits of parameters.
Kritieke Vondst: Harvard's tequila bevat 10 directe pickle.load()-aanroepen. Een kwaadaardig .pkl-bestand kan direct Remote Code Execution (RCE) veroorzaken.
Live PoC: De auteurs hebben een proof-of-concept ontwikkeld die RCE demonstreert via een aangepast quantum-objekt.
Resultaat: 10 CRITICAL bevindingen in tequila; 25 HIGH in TensorCircuit (Tencent).

Klasse IV: QASM Injectie (Nieuwe, Quantum-specifieke Klasse)

Oorzaak: OpenQASM (de assembly-taal voor quantum computers) wordt gebruikt als invoer voor parsers zonder sanitization.
Uniekheid: Dit heeft geen klassiek equivalent (zoals SQL-injectie). Het stelt aanvallers in staat om kwaadaardige gate-definities of register-groottes in te voegen.
Vondsten: Qiskit Terra exposeert 2 ongesanitized API-punten (from_qasm_str, from_qasm_file). tket (Quantinuum) heeft 3 CRITICAL bevindingen in de productie-parser.

5. Supply Chain Analyse

Vendoring: Het Oak Ridge National Laboratory (ORNL) heeft de volledige C++-broncode van IBM's Qiskit Aer verbatim overgenomen in hun XACC-framework. Hierdoor erven ze exact dezelfde 5 CRITICAL en 60 HIGH kwetsbaarheden, zonder dat dit zichtbaar is in standaard scans van XACC's eigen code. Dit is een directe kwetsbaarheidsoverdracht van commercieel naar nationaal laboratorium.
Onafhankelijke Replicatie: Het patroon np.zeros(2**n) is onafhankelijk geïmplementeerd in 14 verschillende frameworks, wat wijst op een structureel gebrek aan beveiligingsnormen in de quantum-community.

6. Significantie en Conclusie

Beveiligingspostuur: Slechts 9 frameworks scoorden 100/100 (o.a. qpp, QuEST, qulacs, MindQuantum), wat bewijst dat deze kwetsbaarheden vermijdbaar zijn met juiste input-validatie.
Systemisch Falen: De kwetsbaarheid is niet inherent aan quantum-wiskunde, maar aan het ontbreken van validatie bij API-ingangspunten. De "32-qubit grens" fungeert als een formele drempel waar normale onderzoekswerkloads (variational quantum eigensolvers) vaak vallen.
Aanbevelingen:
- Implementeer een harde limiet op het aantal qubits bij elke API-ingang (bijv. max 50 voor statevector, max 25 voor density matrix).
- Vervang waarschuwingen door harde fouten (ValueError).
- Update verwerkte (vendored) code en synchroniseer beveiligingspatches.
- Gebruik veilige deserialisatie (geen pickle voor onbetrouwbare bronnen).

De studie concludeert dat de quantum-simulatie-infrastructuur momenteel ernstig kwetsbaar is voor zowel klassieke aanvallen (DoS, RCE) als quantum-specifieke injecties, en dat gecoördineerde ecosystem-interventie noodzakelijk is om de wetenschappelijke integriteit en beveiliging te waarborgen.