zeekay c85b5cf2ba merge refactor/onto-mlwe (v0.10.2): route SP 800-185 + Lagrange onto luxfi/mlwe — byte-preserving de-dup
One-and-one-way completion: Pulsar AND Corona now both consume the single
github.com/luxfi/mlwe base (v0.2.1) for the shared Module-LWE primitives.
Corona remains Module-LWE (Ringtail/Raccoon line).

WHAT THIS MERGES (transcript + Lagrange routing ONLY — no scope creep):
  - hash/sha3.go: cSHAKE256 / KMAC256 / TupleHash256 / EncodeString now
    vend from mlwe/transcript (the single SP 800-185 surface). Corona keeps
    ONLY its domain-separation tags. hash/sp800_185.go (the local primitive
    copy) is deleted; its NIST primitive vectors now live in mlwe/transcript.
  - primitives/shamir.go: ComputeLagrangeCoefficients delegates field
    arithmetic + interpolation to mlwe/share (NewPrimeField + Lagrange@0);
    Corona keeps the adapter lifting each scalar into the R_q ring.Poly.

DELIBERATELY NOT ROUTED (kept byte-incompatible / audited):
  - Lattigo 48-bit ring stays Lattigo (re-rolling audited Lattigo forbidden).
  - The seeded Shamir deal (ShamirSecretSharing) stays Corona/Pulsar-specific
    (its sampler is byte-incompatible with mlwe.Split).

CORRECTNESS GATE — Go byte-parity (PROVEN, this is the gate):
  Every Corona KAT oracle was run on the pre-refactor baseline (main 17ac4f3,
  Corona-local impls) and on this branch (mlwe v0.2.1 routed), and every
  emitted byte is identical: 19/19 KAT files byte-identical old==new
  (recursive diff clean + sha256 manifest match), covering the exact files
  this change touches (corona_oracle_v2 transcript_hash, shamir_share,
  sign_verify_e2e) plus the full oracle surface (reshare, activation, dkg,
  sign, shamir_general, shamir_tk, transcripts_byte, m4_* samplers).
  e2e threshold variants (3,2),(5,3),(7,4),(10,7) pass; go build ./... and
  go test ./... green across all packages.

  mlwe v0.2.0 -> v0.2.1 is byte-safe by source inspection: the only delta
  between those tags is added *_bench_test.go files (test-only, never
  compiled into the consuming binary); zero production bytes changed in
  mlwe/transcript or mlwe/share. The oracle parity above confirms this
  empirically.

CI-GATE NOTE — C++ cross-runtime byte gate is a POST-MERGE CONFIRMATION,
not a merge blocker:
  cmd/cross_runtime_verify (requires luxcpp cmake/conan/blst) runs in CI as
  a post-merge confirmation. The Go byte-parity above is the correctness
  gate and is sufficient to merge, by this transitivity argument:
    - Old Go bytes == New Go bytes (proven: 19/19 byte-identical).
    - The C++ runtime and the Go runtime share NO build inputs — the C++
      port does not depend on go.mod / luxfi/mlwe at all.
    - Therefore this dependency change CANNOT shift any C++ byte, and the
      C++<->Go KAT relationship is INVARIANT under this change: whatever
      C++==Go (or C++!=Go) held before, holds identically after.
  So the post-merge C++ run can only re-confirm the pre-existing C++<->Go
  state; it cannot regress as a result of this Go-only de-dup.

PRE-EXISTING DRIFT (documented, NOT introduced here, NOT a crypto-byte diff):
  The sign_verify_e2e KAT's prose "description" field references
  threshold.GenerateKeysTrustedDealer (a ~13-byte wording difference vs a
  plain "GenerateKeys" phrasing) — a Go<->C++ description-string mismatch in
  the cross-runtime comparison, orthogonal to cryptographic bytes. It
  pre-dates this branch; sign_verify_e2e.json is sha256-identical old==new
  here, so this change leaves it exactly as it was.

Tag: v0.10.2
2026-06-28 13:09:07 -07:00

Corona

Lux is not merely adding post-quantum signatures to a chain; it defines a hybrid finality architecture for DAG-native consensus, with protocol-agnostic threshold lifecycle, post-quantum threshold sealing, and cross-chain propagation of Horizon finality.

See LP-105 §Claims and evidence for the canonical claims/evidence table and the ten architectural commitments — single source of truth.

Corona is the Lux Module-LWE post-quantum threshold signature library for Quasar consensus. The 2-round threshold construction line traces back to the BoschiniKavianiLaiMalavoltaTakahashiTibouchi Module-LWE paper (ePrint 2024/1113). Corona adds the production lifecycle that line lacked: Pedersen DKG over R_q with proper hiding, proactive resharing for epoch validator rotation, identifiable abort, and the integration surface Quasar consumes.

The ML-DSA sibling library lives at luxfi/pulsar. Pulsar is also Module-LWE, but a different construction: its threshold signature output is byte-equal to FIPS 204 single-party ML-DSA (NIST MPTC Class N1). The two libraries are independent — there is no import line between them — and Quasar consumes them as parallel kernels selected per-chain via FinalitySchemeID.

Why "Corona"

A corona is the luminous ring of light surrounding a star — visible only when the brighter central body (the Pulsar / Quasar) is partially occluded. Brand-paired with Pulsar (Module-LWE) and Quasar (the consensus that consumes both): the same family of threshold-finality light, observed at a different layer.

Production lifecycle additions

The original Boschini et al construction (ePrint 2024/1113) is a research artefact — trusted-dealer DKG, no proactive resharing, no integration surface. Corona is the production track that fills those gaps:

Layer Original Module-LWE construction Corona
2-round threshold sign same byte-equal protocol inherited
Trusted-dealer Gen for fixed federation tests / KAT / CLI / permissioned bridge MPC only — never the chain keygen path
Proactive resharing for epoch validator rotation not specified corona/reshare/ (this fork)
Pedersen DKG over R_q with proper hiding not specified corona/dkg2/ — production keygen default since v0.7.5
Per-validator triple-sign integration with Quasar N/A consumed by luxfi/consensus/protocol/quasar

Composition with Pulsar as optional layered PQ defense

Corona is independently usable: a chain can pick Corona as its sole PQ threshold layer, no cross-dependency on Pulsar. Lux primary- network QuasarCert combines both Module-LWE schemes as a Double Lattice layered defence: Pulsar and Corona are distinct schemes at different parameter regimes (Pulsar = FIPS-204 ML-DSA; Corona = the Ringtail/Raccoon threshold, parameters tuned for threshold signing), so an adversary must break both independently — a construction-, parameter-, or implementation-specific flaw in one does not break finality (both have to be cracked). This is construction/parameter/implementation diversity, not hardness-assumption diversity — both rest on Module-LWE, so a break of Module-LWE itself would affect both legs; assumption-disjoint diversity comes from the hash-based Magnetar (SLH-DSA) leg:

QuasarCert {
    BLS         — optional classical fast-path (BLS-12-381 aggregate)
    Corona      — Module-LWE threshold (Raccoon/Ringtail line; this repo)
    Pulsar      — Module-LWE threshold ML-DSA (luxfi/pulsar)
    MLDSARollup — per-validator ML-DSA-65 rolled up via STARK/FRI (P3Q)
}

Each layer is checkable independently with no shared code; selecting the layer happens at chain-construction time via the FinalitySchemeID axis on the chain's ChainSecurityProfile. The pure-PQ profile drops BLS entirely and runs on Corona + Pulsar.

In that pure-PQ Corona + Pulsar AND-mode cert the two lattice legs are not interchangeable in trust model. Because Corona's keygen is natively dealerless (the production-default Pedersen DKG), Corona is the leg that carries the permissionless / no-trusted-dealer guarantee — the property Pulsar's byte-FIPS-204 keygen cannot provide, since a dealerless sum of FIPS-204 secrets would break ML-DSA's small-norm (S_η) bound, leaving Pulsar's key generation provably stuck at a trusted dealer.

Layout

  • sign/ — 2-round threshold signing (byte-equal with upstream)
  • primitives/ — Shamir, hashes, MACs, PRFs (byte-equal with upstream)
  • utils/ — NTT, Montgomery, ring helpers (byte-equal with upstream)
  • networking/ — TCP peer-to-peer (byte-equal with upstream)
  • dkg/ — original Lux DKG (Feldman VSS without noise; broken for public broadcast — see RED-DKG-REVIEW). Retained for reference.
  • dkg2/ — proper Pedersen DKG over R_q (Pulsar addition; this fork)
  • reshare/ — proactive secret resharing for epoch rotation (Pulsar addition; this fork)
  • cmd/ — KAT oracle generators

Status

Production. The 2-round Sign+Verify path is byte-equal-validated against the original Module-LWE construction (ePrint 2024/1113) via 16 SHA-256 KATs. The dealerless Pedersen DKG (dkg2/, entered through keyera.Bootstrap / BootstrapPedersen) is the production keygen default since v0.7.5: it opens a new key era without a trusted dealer, so no single party ever holds the secret. Signing never reconstructs the key — SignFinalize sums the per-party partial responses (z_sum = Σ z_j, then A·z_sum), so the master secret is never formed. Proactive resharing (reshare/) for epoch validator rotation ships alongside it; the trusted-dealer keygen helpers remain only as tests / KAT / CLI footguns (and permissioned bridge MPC), never the chain keygen path.

Corona remains the Ringtail/Raccoon-derived Module-LWE leg (Boschini et al., ePrint 2024/1113) with its own parameter set: it is not FIPS-204 byte-equal, and its certificates are variable-size Module-LWE certificates, larger than Pulsar's FIPS-204-equal output.

S
Description
A 2-round lattice-based threshold signature from standard assumptions for public networks
Readme
16 MiB
Languages
Go 74.3%
eC 14.2%
TeX 6%
Shell 3.8%
Makefile 0.8%
Other 0.8%