Safeguard
Supply Chain Security•

NIST Entanglement Experiment Explained: Quantum Position Verification, What It Proves and What Defenders Should Do Today

NIST used entangled photons to verify a location in a Nature paper. What quantum position verification proves, its limits, and the software security work that matters today.

Safeguard Security Team
36 min read

On 18 November 2026 a team at the U.S. National Institute of Standards and Technology (NIST) published a paper in Nature titled "Quantum position verification with remote untrusted devices". Headlines turned it into "entanglement could thwart hackers and scammers". The real result is narrower and more interesting. The team used pairs of entangled photons to confirm that a participant was at a particular spot between two stations on a campus. It is a proof of location, not a new way to encrypt data, and it ran in a lab building, not on the internet.

This post explains what was demonstrated in plain terms, what the physics does and does not guarantee, how far it sits from anything you could deploy, and why none of it changes what most organizations should do this quarter. The honest defender's view is that the near-term risk is rarely broken mathematics. It is broken implementations, exposed credentials, vulnerable dependencies and agents nobody verified. Safeguard covers the software security layer. It is not a quantum or post-quantum cryptography vendor, and this post does not pretend otherwise.

Key takeaways

  • The experiment is quantum position verification (QPV), not quantum key distribution and not a quantum computer breaking or protecting encryption. It tests whether a remote party really is where it claims to be.
  • It uses entangled photons, superconducting detectors and a loophole-free Bell test, so security rests on observed correlations rather than on trusting the prover's hardware. That is what "device-independent" and "untrusted devices" mean here.
  • The setup was two verifier stations 195 meters (640 feet) apart inside one NIST research building in Boulder, Colorado, with fiber running through hallways. Each verification took roughly two to four minutes of data.
  • The security holds against attackers with little or no shared entanglement. Stronger attackers need longer strings of random bits, and no quantum protocol of this kind can beat adversaries with unlimited pre-shared entanglement.
  • The researchers say real-world use is likely more than a decade away, and a handheld version could take several decades. This is a research result, not a shipping product.
  • Separately, the cryptography your software uses today has a defined migration path: NIST finalized three post-quantum standards in 2024 and selected a backup key-establishment algorithm in 2025. That migration is a software inventory problem.
  • Most real breaches come from implementation flaws, vulnerable or compromised components, leaked credentials and over-trusted automation. Those are fixable today with ordinary software security practice.

What the physicists actually demonstrated

The paper is by Kavuri, Zhang, Gookin and colleagues, with L. K. Shalm as senior author, from NIST and partner institutions. It appears in Nature with DOI 10.1038/s41586-026-11247-3. Live Science covered it on 18 November 2026, quoting Shalm as saying it is "a totally new application for quantum networks".

The problem it addresses is old and practical. Plenty of security decisions depend on where something is. A bank limits access to a trading system to people inside a secured building. A utility accepts remote commands only from a control room. A customer wants to know that the person on a video call really is at the bank branch and not on another continent. The usual tools for proving location are weak. IP geolocation is easy to fake with a proxy. Satellite navigation signals can be spoofed. Even careful timing-based schemes, which measure how long a signal takes to travel, fail against attackers who work together, for reasons covered below.

Position verification in one picture

Picture three parties on a line. Two trusted stations, the verifiers, stand at either end. A third party, the prover, claims to be somewhere between them. The verifiers want proof that the prover is really at that spot.

Each verifier sends the prover a short random message, timed so that both messages arrive at the claimed location at the same instant. The prover combines the two pieces with a simple operation, produces an answer and sends it straight back to both verifiers. Nothing travels faster than light, so a correct answer that arrives within the allowed time proves the prover could not have been far from the claimed spot. This is the same idea as radar or echolocation: send a signal, time the echo.

Why the classical version is breakable

The classical version has a well known flaw. Classical information can be copied. Suppose two dishonest helpers, call them A and B, sit on the line, one between the first verifier and the claimed position and the other between the claimed position and the second verifier. Neither is at the claimed spot, but together they can impersonate a prover that is.

Each helper intercepts the message from the verifier on its side, makes a copy and forwards it to the other helper at light speed. Each now holds both pieces. Each computes the answer and replies to its own verifier. On a straight line the timing works out exactly. The relayed copy reaches each helper just as the honest prover's reply would have had to leave from that helper's position, because the head start each helper has toward its own verifier is spent on the relay. The verifiers see a perfectly timed answer and conclude the prover is in the right place. It is not.

Researchers showed around 2009 that no purely classical position verification scheme can resist colluding attackers like this. That is the gap quantum physics is meant to close.

What entanglement adds

Quantum information cannot be copied. The no-cloning theorem says you cannot make an independent duplicate of an unknown quantum state. That breaks the relay trick. If the key ingredient is a single photon whose state matters, only one place can hold it. If the answer depends on measuring that photon in a way that depends on both verifier messages, the party holding the photon needs both messages at the right moment. A pair of colluders cannot each hold the photon.

The experiment uses entangled photon pairs. Entanglement means two particles share a joint state that cannot be described as two separate states. Measure one, and the pattern of results across many pairs shows correlations with the other that no classical, pre-agreed strategy can reproduce. One verifier creates pairs of entangled photons, keeps one photon of each pair and sends the twin to the prover. At the same time both verifiers send their random bits, timed to meet at the prover. The prover combines the bits with a simple math operation and uses the result to choose how to measure the photon's polarization, which is the direction in which its electric field oscillates. A detector records whether the photon passed the filter, and the prover returns that yes or no to both verifiers.

Because the verifiers kept the other half of each pair, they can compare notes afterward. That comparison is where the Bell test comes in.

The Bell test, and why it makes the devices untrusted

In 1964 John Bell showed that any theory in which particles carry pre-set properties and nothing travels faster than light predicts limits on how strongly separated measurements can be correlated. Quantum mechanics predicts that entangled particles can exceed those limits. In the common CHSH form of the test, a classical model can score at most 2, while quantum mechanics allows up to about 2.83, which is 2 times the square root of 2. Seeing a score above 2 rules out the classical explanation.

For decades such tests had loopholes. Detectors missed too many photons, so a hidden classical model could in principle hide in the missing data. Measurement settings were not always chosen far enough apart in space and time for the locality assumption to hold. In 2015 several groups closed the main loopholes together, including a photon experiment with NIST involvement and a separate electron spin experiment over 1.3 kilometers. Those were landmark physics results, and they showed it could be done at all.

A loophole-free Bell test has a useful property for security. If the observed statistics violate the Bell bound, the measurement results could not have been produced by a device following a pre-written classical script, whatever the device's internals are. The security argument depends on the observed numbers, not on trusting the manufacturer. Physicists call that device-independent. Ekert proposed using Bell's theorem this way for key distribution in 1991. The NIST experiment applies the same logic to position, which is why the paper title says "remote untrusted devices". The prover's equipment sits far from the verifiers, and the verifiers do not have to trust it. They check the statistics.

If anyone tampers with the photons or the equipment, the test fails. That is the point.

The numbers

The details matter, because they show how much stood between this result and a product.

ItemWhat the paper and coverage report
Verifier separation195 meters (640 feet), linked by cable and optical fiber through hallways of a NIST building
DetectorsSuperconducting detectors that catch nearly every photon
Trial rateAbout 250,000 trials per second
Rounds per verification30 million to 60 million, roughly two to four minutes of data
Verifications run335 over two days in fall 2024, nearly all passed
Localization gainVolume 4.53 times smaller than classical protocols with identical latencies; one dimensional localization 2.47 times smaller than the best non-remote classical protocol
Adversary modelAttackers who, before each trial, share little or no entanglement
Stated speedup pathFaster measurement devices could cut a verification from minutes to about a second

Two things stand out. First, the result is a statistical claim, built from tens of millions of rounds, not a single yes or no from one photon. Second, the headline improvement is about how tightly the location is pinned down compared with the best classical alternative. It is a certified quantum advantage in the physics sense, and it is a modest multiple, not an unbreakable seal.

The loss tolerance is the part experts found notable. Many earlier designs could tolerate losing only a few percent of the photons on the way, which Shalm called not practical with today's technology. The Bell-test protocol tolerates much more loss, and the superconducting detectors made the first full demonstration possible. Shalm told Live Science that getting this strongest version to work on a first demonstration of a full protocol was a surprise.

What it does not show

Careful reading prevents the most common overreading of this paper.

It does not break or protect your encryption. QPV answers "where is this party?" It has no bearing on whether RSA, elliptic curves or AES hold up. Anyone selling it as a defense against a quantum computer cracking TLS has misunderstood it.

It does not make location unspoofable in general. The security proof covers a defined attacker model. The paper's experiment is secure against attackers who share little or no entanglement of their own, and stronger adversaries need longer random strings. A foundational result from 2010 and 2011 showed that any quantum position verification scheme can be defeated by attackers with enough pre-shared entanglement, and that the entanglement needed grows very fast with the number of qubits involved. The practical security question is therefore what a realistic attacker could prepare. That is a bound, not a guarantee against everyone.

It does not run over the internet. The two verifiers and the prover were connected by purpose-built fiber and cable on one campus. A real deployment needs high quality quantum networks that share entangled photons between parties. Those do not exist at scale.

It is not fast or small. Each verification took minutes. The equipment includes superconducting detectors and lab-grade photon sources. Shalm's own comparison was to building-sized computers of the 1950s and 1960s, not to smartphones. A compact handheld version, he said, might be possible in several decades with steady improvement.

It does not remove the need for classical security around it. A verified location is one input to an authorization decision. The system that consumes it is still ordinary software with ordinary bugs.

How far from deployment

The researchers are direct. NIST physicist Scott Glancy, a co-author, said real-world use may be more than a decade away. Shalm expects the first users to be data centers, financial back-end systems and critical infrastructure such as power plants, where the cost and size are tolerable. Phones come much later. He also said, in his words, that it may not be this year, but the team knows the steps needed to get there. The paper identifies two: faster measurement devices to shorten each check to about a second, and low-latency links that could shrink the verified zone to a single building even with stations miles apart.

Here is a fair way to read the timeline. The physics has crossed a threshold. A full protocol runs, with a Bell-test security argument, and the results are published in a leading journal. The engineering distance to a product is still large. Treat QPV as a research result that may become one tool in a position-based authentication toolbox in the 2030s, and plan your 2026 security budget around the threats that exist in 2026.

Where this sits next to other quantum security work

The word "quantum" covers several different things in security. Mixing them up is the fastest way to misjudge risk.

TopicWhat it isStatus in 2026Does it change your software controls?
Quantum position verificationProving a party's location using entanglement, timing and a Bell testLab demonstration published in Nature, 18 Nov 2026No
Quantum key distribution (QKD)Sharing encryption keys using quantum states, so eavesdropping disturbs themLab and limited network deployments, specialized hardware, distance and integration limitsNot for ordinary application software
Device-independent QKDQKD whose security rests on a Bell test, as Ekert proposed in 1991Research demonstrations, far harder than standard QKDNo
Post-quantum cryptography (PQC)Classical algorithms designed to resist quantum computers, running on ordinary hardwareStandards published, libraries shipping, migration underwayYes, it is a software migration
A cryptographically relevant quantum computerA machine able to run Shor's algorithm against RSA and elliptic curves at useful sizesNot publicly demonstratedIt sets the clock for the PQC migration

The one row that touches your code is post-quantum cryptography. It runs on the servers, libraries and devices you already operate. Everything else in the table is physics or specialized hardware.

Quantum-resistant thinking you can start today

Because the interesting physics is years away from practical use, the useful question is what to do now. Two threads matter: the cryptography migration, and the broader point that cryptography is software.

The threat model behind post-quantum migration

Shor's algorithm, published by Peter Shor in 1994, lets a sufficiently large quantum computer factor integers and compute discrete logarithms efficiently. That would break RSA, Diffie-Hellman and elliptic curve schemes, which protect most key exchange and digital signatures in use. Grover's algorithm gives a smaller, square-root speedup against symmetric ciphers and hashes, which is usually handled by using larger key and output sizes.

No one has publicly demonstrated a machine that can do this at useful sizes. The reason organizations act anyway is "harvest now, decrypt later". An attacker who records encrypted traffic today can store it and decrypt it if a capable machine appears in ten or fifteen years. Data that must stay confidential for that long, such as health records, long-lived trade secrets and certain contracts, is at risk now even though the machine does not exist yet. Signatures are a different timeline. A forged signature is only useful if the verifier still accepts the old algorithm at the moment of forgery, which makes the deadline about when you stop trusting the algorithm, not about the date of an attack.

What NIST has standardized

NIST finalized its first three post-quantum standards in August 2024.

  • FIPS 203 specifies ML-KEM, a module-lattice-based key-encapsulation mechanism for establishing shared keys.
  • FIPS 204 specifies ML-DSA, a module-lattice-based digital signature scheme.
  • FIPS 205 specifies SLH-DSA, a stateless hash-based signature scheme, built on different mathematics from the lattice schemes.

In March 2025 NIST selected HQC as a fifth algorithm for post-quantum encryption, as a backup based on a different mathematical approach from ML-KEM. NIST's Dustin Moody said organizations should keep migrating to the standards finalized in 2024. The backup exists in case ML-KEM turns out to be vulnerable, not as a replacement.

NIST's draft transition report, NIST IR 8547, sets out the expected timeline. In its initial public draft from November 2024, quantum-vulnerable algorithms providing 112 bits of security are deprecated after 2030, and quantum-vulnerable public-key algorithms are disallowed after 2035. It is a draft, so check the current version before you quote dates to a customer or an auditor.

Libraries are already shipping this

This is not hypothetical future software. OpenSSL 3.5.0 added support for ML-KEM, ML-DSA and SLH-DSA, and changed its default TLS key shares to offer the hybrid X25519MLKEM768 alongside X25519. Go 1.24 added a crypto/mlkem package implementing ML-KEM-768 and ML-KEM-1024. A hybrid key exchange pairs a classical algorithm with a post-quantum one so that an attacker must break both. An IETF draft specifies the hybrid ECDHE with ML-KEM approach for TLS 1.3.

That matters for supply chain thinking. The moment your base image, runtime or TLS library updates, your service's cryptographic behavior can change without anyone editing your code. Which library version you run is now a security-relevant fact, not a footnote.

Crypto agility and the cryptographic inventory

Every credible migration guide starts with the same step: know where cryptography lives in your estate. In a typical software organization, cryptography shows up in places teams forget to list.

  • Direct calls to crypto libraries in your own code.
  • Transitive dependencies that bundle their own implementations or pin an old version.
  • TLS terminated by a language runtime, a web server, a service mesh or a managed load balancer.
  • Container base images, which carry system crypto libraries and certificate bundles.
  • Code signing and artifact signing, which use signature algorithms that are quantum-vulnerable today.
  • Embedded firmware and third-party agents that ship their own crypto and update on the vendor's schedule.
  • Certificates and the certificate authorities behind them. See our posts on what a certificate authority is and certificate authority compromise risks.

CycloneDX 1.6 added a Cryptography Bill of Materials (CBOM), which describes cryptographic assets such as algorithms, keys and certificates in the same document family as a software bill of materials. CycloneDX is standardized as ECMA-424. A CBOM is the right shape for the inventory. This post does not claim that Safeguard generates a CBOM. It is a format your inventory tooling can use, and it shows where the industry expects this work to land: next to the SBOM, built from the same component data.

Crypto agility means designing so an algorithm can be swapped without a rewrite. In practice that means algorithm names in configuration rather than in code, narrow wrapper interfaces around crypto calls, tests that exercise more than one algorithm, and an owner for each place that terminates TLS or signs something.

The near-term risk is broken implementations, not broken math

Here is the part that deserves the most attention. Even in the world where a quantum computer arrives on schedule, most of the real-world damage in the meantime comes from software that uses sound mathematics badly. A short history shows the pattern.

IncidentWhat failedWhat did not fail
Heartbleed, CVE-2014-0160 (April 2014)A missing bounds check in OpenSSL's TLS heartbeat handling let remote clients read chunks of server memory, which could include private keys and session dataTLS and RSA mathematics
Debian OpenSSL weak keys, CVE-2008-0166 (May 2008)A packaging change removed a source of randomness, leaving a small set of possible keys for each key type and sizeThe key generation algorithms
ROCA, CVE-2017-15361 (October 2017)A flaw in one vendor's RSA key generation code made affected keys practically factorableRSA itself

In each case the cryptography was sound and the code around it was not. A quantum computer would add nothing to those attacks, and a post-quantum algorithm would have changed nothing about them. The lesson is not that cryptography does not matter. It is that the layer that fails first is the implementation, the dependency tree and the process around it.

The same pattern shows up well beyond cryptographic libraries.

  • Vulnerable dependencies. Applications carry hundreds of transitive packages. A flaw in any one of them, including a crypto helper, is a flaw in your product. The practical questions are whether you know which version you run, whether the vulnerable function is reachable from your code, and how fast a fixed version lands in production.
  • Compromised components. Package registries and build systems are attack targets. See our write-up on what to do when a dependency is compromised and how an SBOM helps find affected products fast.
  • Exposed credentials. Long-lived tokens and keys in repositories, build logs and chat history give attackers a valid identity, which no amount of algorithm strength fixes. Rotation, short lifetimes and a proper secrets manager are the answer, and they come from your secrets management practice.
  • Weak application behavior. Injection, broken authorization and misconfiguration in a running application are found by testing the running application. Dynamic testing exists for exactly this reason.
  • Unverified agents. AI agents now hold credentials, call tools and take actions on behalf of people. An agent whose identity, permissions and tool access nobody tracks is a new place for the old confused deputy problem.

Quantum position verification and post-quantum cryptography are both answers to a question about trust in a signal. Most incidents come from the trust placed in code, packages and automation that nobody checked.

Why location proofs still need software security

Suppose QPV works at scale in 2035. A system now accepts a command only if the sender is provably inside a specific room. What did that buy, and what does it leave open?

It buys protection against remote impersonation. A phone call, a video call or a network request that claims to come from a secure site can be checked against a physical anchor.

It leaves everything on the inside of the room. The software that receives the command still has to parse it, authorize it, log it and carry out the action. The device in the room can run a vulnerable library. The operator can paste a token into a ticket. The agent acting for the operator can be tricked by a prompt injection. A verified location tells you where the request came from. It tells you nothing about whether the receiving system is trustworthy, patched or correctly configured.

This is why defenders can read the NIST result with interest and then go back to the work in front of them. Each layer of assurance helps, and each one depends on the layers beneath it being sound.

A practical plan for this quarter

None of the following needs a quantum anything. Each step reduces real risk now and also makes a later post-quantum migration cheaper.

Step 1: Build a component inventory you can query

You cannot migrate, patch or investigate what you cannot list. Generate a software bill of materials for every application and container image, in SPDX or CycloneDX, and keep it current with each build. The inventory should answer "which of our products contain this library at this version" in minutes. That is the same question you will ask the day a crypto library has a serious flaw, and the same one you will ask when you plan a switch to a post-quantum library.

Step 2: Find where cryptography lives

From the inventory, list every component that implements or wraps cryptography, and every place TLS terminates. Start with a rough pass on your own code. For example, search for common crypto call sites and algorithm names:

# Rough first pass, not a complete audit
grep -rIn --include='*.go' --include='*.py' --include='*.java' --include='*.js' --include='*.ts' \
  -E 'RSA|ECDSA|ECDH|X25519|AES|SHA-?1|MD5|crypto/' . | head -100

Treat the output as a starting list. Then record, for each hit, which algorithm is used, what it protects, how long that data must stay confidential, and who owns the code. MD5 and SHA-1 hits deserve a note because they are weak today, independent of quantum computing.

Step 3: Rank by how long the data must stay secret

Not everything needs the same urgency. A short-lived session token protecting a low-value request is not a harvest-now target. A backup archive of customer health data, a long-term signing key and a firmware update channel are. Rank your cryptographic uses by confidentiality lifetime and by how hard they are to change later. Hard to change and long-lived goes first.

Step 4: Test hybrid and post-quantum support in staging

If your stack uses OpenSSL 3.5 or later, or Go 1.24 or later, hybrid key exchange is available. Check what your TLS terminators and clients negotiate, and what breaks when they offer larger key shares. Larger handshakes can trip middleboxes and old clients. Find that in staging, not in production.

Step 5: Make every change policy gated

Whether you are upgrading a crypto library, rotating a key or swapping a base image, the change should pass through the same gates: a pull request, your own CI tests, a policy check on the components involved and an approval. Automation is welcome. Unreviewed automation is how a security fix becomes an outage.

Step 6: Verify who and what is acting

For people, use phishing-resistant authentication. For automation and AI agents, track which agent holds which access, restrict the tools it can call and log what it did. A proof of location for the human operator does not help if the agent acting on their behalf has a standing token that works from anywhere.

Step 7: Watch the standards, not the headlines

Subscribe to NIST's post-quantum project updates, your TLS library release notes and your language runtime release notes. Re-read the transition timeline when the draft report becomes final. Treat research results like the NIST position verification paper as context, and let standards bodies set your deadlines.

A decision table for security leaders

Your questionHonest answer todayWhat to do
Do I need to buy quantum hardware?No. The NIST result is a lab demonstration, and QKD needs specialized linksNothing to buy for QPV. Watch it
Do I need to plan for post-quantum cryptography?Yes, as a multi-year software migrationInventory, rank, test hybrid, migrate by priority
Will QPV replace my access controls?No. It could become one more input to them, a decade or more outKeep strong identity, least privilege and network controls
Where will I most likely get breached this year?Vulnerable dependencies, leaked credentials, misconfiguration, over-trusted automationFix those first
Can one product do all of this?No. Cryptography libraries, hardware and software security each have ownersCover your software layer well and track the rest

Where Safeguard fits

Safeguard is a software security platform. It is not a quantum security product, it does not provide quantum key distribution or position verification, and it is not a post-quantum cryptography vendor. It does not implement or replace the cryptographic libraries you use. What it covers is the software layer that sits around and underneath cryptography, which is where the incidents in the table above happened.

In plain terms, here is the overlap with the plan above.

  • Component inventory and SBOMs. Safeguard generates and analyzes software bills of materials in SPDX and CycloneDX, so "which of our products carry this library" becomes a query. That is step 1, and it is the foundation for any future crypto migration.
  • Software composition analysis and reachability. Vulnerable dependencies, including crypto libraries, are matched to known vulnerabilities, and static reachability analysis helps rank the ones your code actually calls. How much noise that removes depends on your codebase, so measure it during an evaluation.
  • Remediation. When a fixed version exists, Griffin, Safeguard's security model, opens a policy gated pull request, and your own CI runs your tests before anyone merges. The verbatim section below describes this, and Gold, in full.
  • Dynamic testing. DAST tests a running application, which is where authorization and input handling flaws appear.
  • Policies and gates. Rules enforced at build, CI and release stop known-bad versions from shipping.
  • Agents and AI tooling. The MCP Guardrail proxies MCP servers so tool access is controlled, and agent identity tracks which agent holds what access at what level.
  • Compliance. Evidence for frameworks your auditors ask about, with Safeguard itself audited for SOC 2 Type I and Type II.

What it does not do is just as clear. It does not tell you which post-quantum algorithm to choose, it does not generate quantum-safe keys and it does not verify anyone's physical location. Pair it with your cryptography owners, your TLS and library maintainers, and the standards your industry follows.

If you want to see how this looks in a terminal, the Safeguard CLI works from the same inventory and policy data. You can also download Safeguard and read the CLI docs.

Common mistakes

  • Reading QPV as a replacement for encryption. It proves location. It does not protect data in transit or at rest.
  • Buying "quantum-safe" labels without an inventory. If you do not know where your cryptography lives, a label on one product does not move your risk.
  • Waiting for a quantum computer to appear. Harvest-now-decrypt-later and long migration lead times mean the planning window is now, even though the machine is not here.
  • Ignoring weak classical crypto while chasing post-quantum. MD5, SHA-1, small RSA keys and hardcoded keys are exploitable today.
  • Treating cryptography as a library choice made once. Your base image, runtime and TLS terminator can change behavior on the next update.
  • Pinning crypto libraries forever. An old pinned version freezes in every bug fixed since.
  • Giving agents standing, location-independent credentials. A location check for the human is moot if the agent has a token that works anywhere.
  • Quoting deadlines from draft documents as final. NIST IR 8547 was an initial public draft when it was published. Check the current status.

FAQ

What did NIST actually demonstrate with quantum entanglement?

NIST physicists used entangled photon pairs, superconducting detectors and a loophole-free Bell test to verify that a participant was located between two stations 195 meters apart in a NIST building. The paper calls this quantum position verification. It is a location proof, and it is the first complete demonstration of its kind, per the researchers.

Is this quantum key distribution?

No. QKD distributes encryption keys using quantum states. Quantum position verification checks where a party is. Both can use entanglement and both can use Bell tests, but they answer different questions.

What does device-independent mean here?

The security argument rests on observed statistics from a Bell test rather than on trusting the equipment. If the correlations exceed what any classical strategy allows, the results could not have come from a pre-scripted device. The paper's title refers to this as remote untrusted devices.

Can quantum position verification stop phishing and scams today?

No. It is a lab result. The researchers describe real-world use as likely more than a decade away, with data centers, financial back ends and critical infrastructure as the first likely users. Phone-sized versions would take much longer.

Can an attacker still spoof a quantum-verified location?

Within limits. The experiment is secure against attackers with little or no shared entanglement. Earlier theory shows that attackers with enough pre-shared entanglement can defeat any such scheme, so the real question is what resources an attacker can prepare. The authors note that stronger adversaries require longer strings of random bits.

Does this mean RSA and TLS are about to break?

No. The experiment says nothing about the strength of RSA or TLS. The separate concern is that a large quantum computer running Shor's algorithm could break RSA and elliptic curve cryptography. No such machine has been publicly demonstrated, and NIST has published post-quantum standards for the migration.

Which post-quantum standards exist?

NIST finalized FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) and FIPS 205 (SLH-DSA) in August 2024, and selected HQC as a backup encryption algorithm in March 2025. OpenSSL 3.5 and Go 1.24 already ship support for ML-KEM.

Should my team start a post-quantum migration now?

Start the inventory and prioritization now. Test hybrid key exchange in staging where your libraries support it. Migrate by priority, starting with long-lived confidential data and hard-to-change systems. Large-scale cutovers can follow the final standards and your vendors' releases.

Is Safeguard a quantum or post-quantum cryptography vendor?

No. Safeguard is a software security platform covering component inventory and SBOMs, vulnerability analysis, remediation pull requests, dynamic testing, policies, agent and MCP controls and compliance evidence. It does not implement cryptographic algorithms or provide quantum products.

What is the biggest near-term risk for most organizations?

Implementation and process failures: vulnerable or compromised dependencies, leaked credentials, misconfiguration and over-trusted automation. Those are present today and fixable with ordinary software security practice.

Where can I read the original paper?

It is in Nature at DOI 10.1038/s41586-026-11247-3, titled "Quantum position verification with remote untrusted devices". Read it before you quote its numbers.

Cryptography is software, so the same supply chain hygiene applies to it as to any other dependency. A post-quantum library update, a base image change or a compromised package all reach production through your build, and the gap between a fix being published and the fix running in your builds is where the exposure lives.

Fix it without waiting for upstream

Whatever the vulnerability, most of the risk sits in two gaps. The first is the time between a fix being published and that fix actually running in your production builds. The second, and worse, is the time before any fix exists at all, while a maintainer works out a patch and a release schedule. Waiting through both gaps is a habit, not a requirement. Safeguard gives teams three ways to close them.

1. Autonomous remediation: pull requests, not tickets

When a fixed version exists, Griffin, Safeguard's security model, opens a policy gated pull request that moves the affected dependency to the safe version, and your own CI runs your tests on it before anyone merges. You can run it on one repository or in bulk across every project that carries the vulnerable version. Remediation categories include dependencies, licenses, security posture and findings, and each one is set separately. Reachability analysis ranks the vulnerable code paths your application actually calls first, so the first pull requests you merge are the ones that matter most. Auto-merge is a separate switch and stays off by default, so your team decides what merges on its own and what still needs a human approval.

2. Gold Open Source: the safe version in seconds, free

gold.safeguard.sh is free and needs no login. Search any CVE or package to see affected and fixed versions, CVSS, EPSS, CISA KEV status and a recommended safe version, or use the "Am I affected?" checker. The same data is available through a free read API, README status badges and RSS threat feeds.

3. Gold Registry: start from components that are already fixed

Safeguard Gold rebuilds patched versions of open-source packages and images from source, signs each build, attaches an SBOM, SLSA provenance and VEX, and serves them from registry.safeguard.sh to your organization. Every Gold artifact is held continuously to zero exploitable critical or high CVEs and a completed license check, with signed build provenance (signed with Safeguard's key and verifiable with cosign, SLSA Build Level 3 as the design target) and a public evidence page you can hand to an auditor. An artifact loses its Gold badge if it regresses. Teams can point their own package directory at the registry so hardened equivalents resolve without changing how developers install anything.

When upstream has no fix yet, or will not ship one, Safeguard first works to get the fix accepted upstream. If the issue is severe or upstream will not move, Safeguard builds a fork, fixes the vulnerability there and publishes a hardened Gold build, so you are not stuck on a maintainer's release schedule. You can also request a hardened build of a specific package. Ask which packages it covers before you plan around it.

Your situationWhat to use
A fixed version existsAutonomous remediation opens the upgrade pull request; Gold Open Source confirms the safe version
You need to know today whether you are affectedGold Open Source lookup and "Am I affected?" checker, free and without login
You want vulnerable versions to stop shippingSafeguard policies and gates in CI
Upstream has no fix yet, or will not ship oneA custom Gold request; fork and patch
You want to start clean on new projectsPull hardened components and images from Gold Registry

One honest limit: when the vulnerable code lives in a vendor appliance, a hosted service or an operating system runtime you do not build yourself, the fix still has to come from that vendor or distribution. The steps above apply to the open source dependencies and container images you build and ship, which is where most teams carry the largest and least tracked share of their exposure.

See how Safeguard would help

None of these demos shows quantum or cryptographic functionality. Each shows a Safeguard surface for the software layer around it: fixing a vulnerable dependency, scanning from your own machine and controlling what an agent can do. You can download Safeguard and follow the CLI docs to try them.

This is a real CLI session. Asked to fix a lodash CVE, the CLI reads the finding and advisory, asks before any command that changes something, edits package.json to lodash 4.17.21, runs npm install and npm test with approval, prints a summary and pushes nothing. The same flow applies when the vulnerable dependency is a crypto helper instead of lodash.

Click through it at your own pace, or open it full screen.

This demo connects Claude to the Safeguard MCP server with OAuth and lets you choose which tools Claude can use. It is the allow-list idea from step 6: a person decides which tools an agent may call, and the agent does not get everything by default.

Click through it at your own pace, or open it full screen.

This demo sets up the local runner on your own machine, approves it with a device code, then scans from the terminal. It suits teams that want an inventory and scan results without handing over repository access, which helps when the first step is simply finding out what you run.

Click through it at your own pace, or open it full screen.

Quick check

The NIST experiment verified a location with entangled photons. Does it change how you should protect data in transit this year?

No. Quantum position verification proves where a party is. It does not encrypt anything and it runs only in a lab. The relevant changes for data in transit are ordinary: keep TLS libraries current, inventory where cryptography lives and test hybrid post-quantum key exchange in staging.

A vendor says its product is quantum-safe. What do you ask first?

Ask which algorithms it uses and for what, which standard they follow, and which library versions ship in the product. A label without those answers does not tell you where your risk sits. Then check the same product for vulnerable dependencies, because Heartbleed-style implementation flaws matter more than the algorithm name.

Sources

Last reviewed: 22 November 2026. The NIST position verification result is a research demonstration, and IR 8547 was an initial public draft when this was written; check the current status of each before relying on dates.

Never miss an update

Weekly insights on software supply chain security, delivered to your inbox.

We email you a link to confirm, and only then add you to the list. Unsubscribe in one click. Privacy

Self-healing security runs on Safeguard.

Your first fix PR is minutes away.

No sales call required, even your agent can complete the purchase over MCP.