SQIsign

SQIsign's public key and signature together fit in under 300 bytes at the lowest security level, less than a single ML-DSA public key. It gets there with the most intricate mathematics of any candidate, and in 2026 a new attack forced its parameters up.

Status
Round 3 of NIST's additional-signatures process (NIST IR 8610, May 2026); not a standard
Rests on
Computing the endomorphism ring of a supersingular elliptic curve, equivalent to finding isogenies between supersingular curves
Sizes (version 3.0, level I)
83-byte public key, 200-byte signature
Speed (version 3.0, level I)
93.9 million cycles to sign, 12.1 million to verify, optimised code on an Intel Core i7-13700K
Prime (level I)
p = 3·2324 − 1, up from 5·2248 − 1 in round 2

Why it matters

Every post-quantum signature standard so far costs kilobytes: ML-DSA-44 needs 3,732 bytes for a public key and a signature together, and SLH-DSA more. For certificate chains, constrained devices and anything that stores many signatures, that is a real cost. SQIsign's 283 bytes at level I is less than RSA-2048's 512.

It also rests on a different kind of problem. The endomorphism ring problem has nothing to do with lattices, codes, multivariate equations or hash functions, so a break of one of those would leave it untouched. That diversity is exactly what NIST's additional-signatures process is looking for.

The costs are signing speed, implementation complexity, and a security estimate that moved recently. Its designers list all three.

The hard problem

An endomorphism of an elliptic curve E is an isogeny from E to itself, and together they form its endomorphism ring End(E). For a supersingular curve over Fp2, End(E) is a maximal order in a quaternion algebra, and the Deuring correspondence matches curves with such orders, and isogenies between curves with ideals between orders. Computing End(E) from E alone is believed hard.

Knowing End(E) is powerful. Given the endomorphism rings of two curves, an isogeny between them can be computed in polynomial time, and Wesolowski proved in 2021, assuming the generalised Riemann hypothesis, that the endomorphism ring problem and the isogeny path problem are equivalent under reductions of polynomial expected time. A SQIsign key pair is a curve Epk whose endomorphism ring only the signer knows.

Signing

SQIsign is a sigma protocol made non-interactive with the Fiat–Shamir transform. The signer proves it knows End(Epk) without revealing it:

  1. Commit. Generate a random curve Ecom together with its endomorphism ring, by walking a secret random isogeny from a public starting curve.
  2. Challenge. Hash the message and the commitment into a challenge isogeny from Epk to a new curve Echl. Knowing End(Epk), the signer can now work out End(Echl).
  3. Respond. Knowing the endomorphism rings of both Ecom and Echl, compute an isogeny between them, and publish it.
  4. Verify. Check that the published isogeny really goes from Ecom to Echl.

A forger without End(Epk) cannot find the response. There is one shortcut the protocol has to close: a cheater who built Ecom from Epk itself could answer by composing isogenies without knowing anything. The fix is to make sure the challenge is never a piece of the response; in version 3.0 the two have coprime degrees by construction.

The hard engineering is in the response. It is an isogeny of large degree, and it has to be both computed and written down compactly. The round-1 scheme used the KLPT algorithm and a representation that was slow to produce. Round 2 adopted the SQIsign2D-West approach: the response is sampled from a well-understood distribution and sent as the images of a few points, and the verifier checks it by computing an isogeny between two-dimensional abelian varieties, the same tool that broke SIDH, used here to build. Signing became nearly 20 times faster, at 103.0 million cycles, and verification more than 6 times faster.

The 2026 attack and version 3.0

For thirty years the best algorithms for the endomorphism ring problem took time about p1/2, and SQIsign's parameters were set on that basis. In 2026 Wesolowski gave a heuristic algorithm that runs in time and memory p1/3+o(1): it searches for a short isogeny from a curve to its Galois conjugate by meet-in-the-middle over smooth-degree isogenies, and turns that isogeny into an endomorphism. The o(1) hides a superpolynomial factor, and the memory is as large as the time, so the effect on concrete parameters is much smaller than the exponent suggests. It is not zero.

Version 3.0 of the specification, submitted for round 3 in September 2026, raised the parameters in response. Its authors estimate the cost of the new attack under a memory limit of 280, 2120 and 2160 stored entries for the three levels, and report total costs of about 2149.8, 2221.8 and 2285.4, against NIST's targets of 2143, 2207 and 2272. They call these parameters "a middle-of-the-road approach" and state plainly that concrete security is in flux, and that a version of the attack without its memory cost would require revisiting them.

Sizes in bytes, from the round-2 (version 2.0.1) and round-3 (version 3.0) specifications.
Round 2 public keyRound 2 signatureRound 3 public keyRound 3 signature
Level I6514883200
Level III97224129306
Level V129292169406

Version 3.0 also replaced the multiple-precision quaternion arithmetic with a fixed-precision representation, removed floating-point arithmetic and the dependency on GMP, and adopted a new algorithm for turning ideals into isogenies. Those changes more than paid for the larger primes in key generation and signing; verification became 1.5 to 2 times slower.

Performance

Millions of cycles for version 3.0's optimised implementation on an Intel Core i7-13700K, median of 1,000 runs, as published in the specification.
Key generationSigningVerification
Level I32.293.912.1
Level III102.1320.331.5
Level V214.5674.777.6

At a few gigahertz, level-I signing takes a few tens of milliseconds, far slower than ML-DSA, and verification a few milliseconds. The designers also publish figures for Apple M4 Pro, ARM Cortex-A76 and Cortex-M4; on the M4 Pro, level-I signing takes 60.0 million cycles.

What to watch

  • Parameters. Refinements of Wesolowski's attack, and above all any version that avoids its memory cost, would move them again. There are plenty of candidate primes of the required shape to move to.
  • Side channels. The specification says a fully constant-time implementation has not yet been achieved. The move to fixed-precision arithmetic is the first step towards one.
  • The assumption. Forging a signature reduces to computing endomorphism rings when given certain hints, which is a variant of the problem rather than the problem itself; version 3.0's change to the response distribution changed those hints, and the designers argue in the specification that it does not weaken them.
  • The process. NIST expects round 3 to last about two years.

SQIsign is not affected by the attacks that broke SIDH: those needed the images of torsion points under a secret isogeny, and SQIsign does not publish them. Nor is it affected by Kuperberg's algorithm, which needs a commutative group action. Its exposure is the classical algorithms for the endomorphism ring problem itself.

Primary sources

  1. SQIsign team, "SQIsign: algorithm specifications and supporting documentation", version 3.0 (September 2026)
  2. L. De Feo, D. Kohel, A. Leroux, C. Petit and B. Wesolowski, "SQISign: compact post-quantum signatures from quaternions and isogenies", ASIACRYPT 2020
  3. A. Basso, L. De Feo, P. Dartois, A. Leroux, L. Maino, G. Pope, D. Robert and B. Wesolowski, "SQIsign2D-West: the fast, the small, and the safer" (2024)
  4. B. Wesolowski, "The supersingular isogeny path and endomorphism ring problems are equivalent", FOCS 2021
  5. B. Wesolowski, "The supersingular isogeny problem in time and memory p1/3+o(1)" (2026)
  6. NIST IR 8610, Status Report on the Second Round of the Additional Digital Signature Schemes (2026)
  7. SQIsign website, with sizes and benchmarks for each platform