From 1f07474b5423284e9e194cb40ee24a09b81ec974 Mon Sep 17 00:00:00 2001 From: Hanzo AI Date: Sun, 10 May 2026 21:38:38 -0700 Subject: [PATCH] crypto/pq/mldsa: KAT vectors + expanded-key form + ethdilithium-compat Adds NIST CAVS-style KAT regression for ML-DSA-44/65/87 and an expanded-public-key form per EIP-8051 (~22,080-byte precomputed A matrix for ML-DSA-65) for verifier-throughput experiments. ethdilithium_compat subpackage re-implements the Keccak-substituted verifier described in ZKNoxHQ/ETHDILITHIUM. NOT FIPS 204; for benchmark and Ethereum-fallback only. Re-implemented from spec - no LGPL code vendored. The strict-PQ path remains crypto/pq/mldsa/mldsa{44,65,87}.{Sign,Verify}. Patch-bump. --- Makefile | 16 +- pq/mldsa/ethdilithium_compat/doc.go | 67 +++ .../ethdilithium_compat.go | 130 +++++ .../ethdilithium_compat_test.go | 235 +++++++++ pq/mldsa/expanded/derive.go | 177 +++++++ pq/mldsa/expanded/doc.go | 45 ++ pq/mldsa/expanded/expanded.go | 245 +++++++++ pq/mldsa/expanded/expanded_test.go | 491 ++++++++++++++++++ pq/mldsa/kats/doc.go | 37 ++ pq/mldsa/kats/internal/gen/main.go | 218 ++++++++ pq/mldsa/kats/kat_test.go | 211 ++++++++ pq/mldsa/kats/regen_test.go | 122 +++++ pq/mldsa/kats/vector.go | 27 + pq/mldsa/kats/vectors_helpers.go | 20 + pq/mldsa/kats/vectors_mldsa44.go | 56 ++ pq/mldsa/kats/vectors_mldsa65.go | 56 ++ pq/mldsa/kats/vectors_mldsa87.go | 56 ++ 17 files changed, 2208 insertions(+), 1 deletion(-) create mode 100644 pq/mldsa/ethdilithium_compat/doc.go create mode 100644 pq/mldsa/ethdilithium_compat/ethdilithium_compat.go create mode 100644 pq/mldsa/ethdilithium_compat/ethdilithium_compat_test.go create mode 100644 pq/mldsa/expanded/derive.go create mode 100644 pq/mldsa/expanded/doc.go create mode 100644 pq/mldsa/expanded/expanded.go create mode 100644 pq/mldsa/expanded/expanded_test.go create mode 100644 pq/mldsa/kats/doc.go create mode 100644 pq/mldsa/kats/internal/gen/main.go create mode 100644 pq/mldsa/kats/kat_test.go create mode 100644 pq/mldsa/kats/regen_test.go create mode 100644 pq/mldsa/kats/vector.go create mode 100644 pq/mldsa/kats/vectors_helpers.go create mode 100644 pq/mldsa/kats/vectors_mldsa44.go create mode 100644 pq/mldsa/kats/vectors_mldsa65.go create mode 100644 pq/mldsa/kats/vectors_mldsa87.go diff --git a/Makefile b/Makefile index b7b02c4..29182a0 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ # Lux Post-Quantum Cryptography Makefile -.PHONY: all test bench clean fmt lint install-deps verify build +.PHONY: all test bench clean fmt lint install-deps verify build gen_kats # Go parameters GOCMD=go @@ -86,6 +86,20 @@ clean: rm -f coverage.out @echo "βœ… Clean complete" +# Regenerate KAT vector files for crypto/pq/mldsa. +# +# The generator is deterministic: a second run produces byte-identical +# output. The kats package itself has a TestRegen_Deterministic guard +# that asserts the checked-in vectors_mldsa{44,65,87}.go files match a +# fresh `go run`. After running this target, commit the regenerated +# files; the test suite then proves they round-trip. +gen_kats: + @echo "Regenerating ML-DSA KAT vectors..." + GOWORK=off $(GOCMD) run ./pq/mldsa/kats/internal/gen -out pq/mldsa/kats + @echo "Validating regenerated vectors..." + GOWORK=off $(GOTEST) -count=1 ./pq/mldsa/kats/... + @echo "βœ… KAT vectors regenerated and validated" + # Install CI tools install-tools: @echo "πŸ› οΈ Installing CI tools..." diff --git a/pq/mldsa/ethdilithium_compat/doc.go b/pq/mldsa/ethdilithium_compat/doc.go new file mode 100644 index 0000000..1ee320f --- /dev/null +++ b/pq/mldsa/ethdilithium_compat/doc.go @@ -0,0 +1,67 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Package ethdilithium_compat is an EVM-friendly ML-DSA variant +// reimplemented from the public description of the ZKNoxHQ +// EthDilithium scheme. NOT FIPS 204; for benchmark and Ethereum- +// fallback ONLY. +// +// # WHAT THIS IS +// +// The strict luxfi PQ profile lives in crypto/pq/mldsa/mldsa65 and +// follows FIPS 204 verbatim, including SHAKE-256 at every Algorithm +// 30 / 31 / 32 / 33 call site. Verifying a FIPS 204 signature on an +// EVM smart contract or in a precompile is expensive primarily +// because the EVM has no native SHAKE-256 instruction β€” every +// absorb/squeeze must be unrolled in solidity at ~20k gas per +// permutation. +// +// EthDilithium addresses this by routing the message-bind hash +// through Keccak-256 instead of SHAKE-256: an EVM verifier already +// has a native Keccak instruction, and our off-chain signer can do +// the same Keccak compression. The signature itself is then a +// standard FIPS 204 signature, but on the Keccak-derived "effective +// message", not on the caller-provided raw bytes. +// +// API +// +// Sign(skBytes, msg, ctx []byte) ([]byte, error) +// Verify(pkBytes, msg, ctx, sig []byte) bool +// +// Both wrap crypto/pq/mldsa/mldsa65 under the hood. The wire format +// of the public key, private key, and signature is identical to +// FIPS 204 ML-DSA-65 β€” only the message preprocessing differs. The +// effective message passed to ML-DSA is: +// +// effMsg = Keccak256("LUX/EthDilithium/v1" β€– uint8(len(ctx)) β€– ctx β€– msg) +// +// where the length-prefix on ctx prevents a (ctx=A, msg=B) signature +// from re-binding against (ctx=Aβ€–B, msg=""). This is the same +// length-prefix discipline FIPS 204 Β§5.2 uses for its own context- +// binding, but it is performed in Keccak-256 rather than SHAKE-256. +// +// # NOT INTEROPERABLE +// +// Signatures produced by this package will NOT verify under +// mldsa65.Verify with the same (msg, ctx) β€” they will verify under +// mldsa65.Verify with the Keccak-derived effMsg. The pk and sig +// byte layouts are identical to FIPS 204 (so an EVM verifier +// expecting ML-DSA-65 wire bytes accepts the same input), but the +// signed payload semantics differ. +// +// Verify will REFUSE pk/sk bytes that do not match the FIPS 204 +// ML-DSA-65 wire size; we deliberately do not silently accept +// other parameter sets so an EVM contract written for ML-DSA-65 +// cannot be tricked into routing through a different verifier. +// +// # NOT FIPS 204 COMPLIANT +// +// This package is for benchmarking and Ethereum-fallback ONLY. +// NOT acceptable under any LUX_STRICT_E2E_PQ profile. +// The strict path is crypto/pq/mldsa/mldsa{44,65,87}.{Sign,Verify}. +// +// The Keccak substitution and message preprocessing here are based +// on the publicly documented EthDilithium variant; the code is +// re-implemented in this package and shares no source with the +// LGPL-3.0 ZKNoxHQ/ETHDILITHIUM reference repository. +package ethdilithium_compat diff --git a/pq/mldsa/ethdilithium_compat/ethdilithium_compat.go b/pq/mldsa/ethdilithium_compat/ethdilithium_compat.go new file mode 100644 index 0000000..a40a161 --- /dev/null +++ b/pq/mldsa/ethdilithium_compat/ethdilithium_compat.go @@ -0,0 +1,130 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package ethdilithium_compat + +import ( + "errors" + "fmt" + + "golang.org/x/crypto/sha3" + + "github.com/luxfi/crypto/pq/mldsa/mldsa65" +) + +// PublicKeySize, PrivateKeySize, SignatureSize re-export the +// FIPS 204 ML-DSA-65 wire sizes. The signature byte layout is +// identical to FIPS 204 ML-DSA-65; only the message preprocessing +// differs. +const ( + // PublicKeySize is the ML-DSA-65 public key byte length. + PublicKeySize = mldsa65.PublicKeySize + // PrivateKeySize is the ML-DSA-65 private key byte length. + PrivateKeySize = mldsa65.PrivateKeySize + // SignatureSize is the ML-DSA-65 signature byte length. + SignatureSize = mldsa65.SignatureSize +) + +// domainTag is the Keccak-256 domain-separation prefix bound into +// the effective-message hash. It identifies the EthDilithium variant +// so a downstream verifier cannot mistake the resulting "effective +// message" for either a raw user message or a FIPS 204 signed +// payload. +// +// We pin the string here rather than parameterizing it; downstream +// EVM verifiers will hard-code the same constant, so making it +// configurable would invite drift. +var domainTag = []byte("LUX/EthDilithium/v1") + +// Errors. They are returned, never panicked. +var ( + // ErrPublicKeySize is returned when pkBytes is not PublicKeySize. + ErrPublicKeySize = errors.New("ethdilithium_compat: public key size mismatch") + // ErrPrivateKeySize is returned when skBytes is not PrivateKeySize. + ErrPrivateKeySize = errors.New("ethdilithium_compat: private key size mismatch") + // ErrSignatureSize is returned when sig is not SignatureSize. + ErrSignatureSize = errors.New("ethdilithium_compat: signature size mismatch") + // ErrContextTooLong is returned when ctx exceeds 255 bytes, + // matching the FIPS 204 Β§5.2 limit. + ErrContextTooLong = errors.New("ethdilithium_compat: context exceeds 255 bytes") +) + +// Sign produces an EthDilithium signature on (msg, ctx) under +// skBytes (a FIPS 204 ML-DSA-65 wire-format private key). The +// returned signature is byte-compatible with FIPS 204 ML-DSA-65 in +// length and encoding, but the payload it commits to is the +// Keccak-256 effective message rather than the raw input. +// +// Determinism: ctx is mixed into the Keccak preprocessing; the +// underlying ML-DSA-65 sign call uses randomized=false, so the +// output is fully deterministic for a given (sk, msg, ctx) tuple. +func Sign(skBytes, msg, ctx []byte) ([]byte, error) { + if len(skBytes) != PrivateKeySize { + return nil, fmt.Errorf("%w: got %d, want %d", + ErrPrivateKeySize, len(skBytes), PrivateKeySize) + } + if len(ctx) > 255 { + return nil, ErrContextTooLong + } + var skBuf [PrivateKeySize]byte + copy(skBuf[:], skBytes) + var sk mldsa65.PrivateKey + sk.Unpack(&skBuf) + + effMsg := keccakEffectiveMessage(msg, ctx) + // We pass empty ctx into ML-DSA because our own ctx is already + // bound into effMsg. Passing the same ctx twice would create + // two independent domain-separation tags for the same input, + // which is undesirable for verifier round-tripping. + sig, err := mldsa65.Sign(&sk, effMsg[:], nil, false) + if err != nil { + return nil, fmt.Errorf("ethdilithium_compat sign: %w", err) + } + return sig, nil +} + +// Verify reports whether sig is a valid EthDilithium signature on +// (msg, ctx) under pkBytes (a FIPS 204 ML-DSA-65 wire-format public +// key). It returns false on any size mismatch and on any malformed +// input β€” boundary defenses match the FIPS 204 verifier's contract. +func Verify(pkBytes, msg, ctx, sig []byte) bool { + if len(pkBytes) != PublicKeySize { + return false + } + if len(sig) != SignatureSize { + return false + } + if len(ctx) > 255 { + return false + } + var pkBuf [PublicKeySize]byte + copy(pkBuf[:], pkBytes) + var pk mldsa65.PublicKey + pk.Unpack(&pkBuf) + + effMsg := keccakEffectiveMessage(msg, ctx) + return mldsa65.Verify(&pk, effMsg[:], nil, sig) +} + +// keccakEffectiveMessage builds the 32-byte effective message: +// +// effMsg = Keccak256(domainTag β€– uint8(len(ctx)) β€– ctx β€– msg) +// +// The length-prefix byte sits between domainTag and ctx so that no +// pair (ctx=A, msg=B), (ctx=Aβ€–B, msg="") can produce the same input +// β€” the prefix byte makes the (ctx, msg) split unambiguous. This +// is the same length-prefix discipline used in FIPS 204 Β§5.2. +func keccakEffectiveMessage(msg, ctx []byte) [32]byte { + h := sha3.NewLegacyKeccak256() + _, _ = h.Write(domainTag) + _, _ = h.Write([]byte{byte(len(ctx))}) + if len(ctx) > 0 { + _, _ = h.Write(ctx) + } + if len(msg) > 0 { + _, _ = h.Write(msg) + } + var out [32]byte + h.Sum(out[:0]) + return out +} diff --git a/pq/mldsa/ethdilithium_compat/ethdilithium_compat_test.go b/pq/mldsa/ethdilithium_compat/ethdilithium_compat_test.go new file mode 100644 index 0000000..4373cc3 --- /dev/null +++ b/pq/mldsa/ethdilithium_compat/ethdilithium_compat_test.go @@ -0,0 +1,235 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package ethdilithium_compat + +import ( + "bytes" + "testing" + + "github.com/luxfi/crypto/pq/mldsa/mldsa65" +) + +// TestSignVerifyRoundTrip exercises the headline path: sign a +// message with EthDilithium, verify it back. No FIPS 204 +// interaction expected in this test. +func TestSignVerifyRoundTrip(t *testing.T) { + seed := bytes.Repeat([]byte{0xE7}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + + msg := []byte("EVM-friendly ML-DSA-65 round-trip") + ctx := []byte("LUX/test/ethcompat") + + sig, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + t.Fatalf("Sign: %v", err) + } + if len(sig) != SignatureSize { + t.Fatalf("Sign returned %d bytes, want %d", len(sig), SignatureSize) + } + if !Verify(pk.Bytes(), msg, ctx, sig) { + t.Fatal("Verify rejected an EthDilithium signature it just produced") + } +} + +// TestNotInteroperableWithFIPS204 asserts the design invariant: a +// signature produced by EthDilithium MUST NOT verify under the +// FIPS 204 verifier on the same (msg, ctx). This protects the +// strict-PQ profile from accidentally accepting compat-only inputs. +// +// (FIPS 204 *will* verify if you feed it the Keccak-derived +// effective message instead β€” that's how the wire format remains +// the same. The test below confirms that, too.) +func TestNotInteroperableWithFIPS204(t *testing.T) { + seed := bytes.Repeat([]byte{0xE8}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + + msg := []byte("interop check") + ctx := []byte("LUX/test/interop") + + sig, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + t.Fatalf("Sign: %v", err) + } + + // Pin 1: FIPS 204 must NOT accept on raw (msg, ctx). + if mldsa65.Verify(pk, msg, ctx, sig) { + t.Fatal("FIPS 204 verifier accepted an EthDilithium signature " + + "on raw (msg, ctx) β€” the variants must not interoperate " + + "by default") + } + + // Pin 2: FIPS 204 MUST accept on the Keccak effective message + // (no ctx, since EthDilithium binds ctx via Keccak). + effMsg := keccakEffectiveMessage(msg, ctx) + if !mldsa65.Verify(pk, effMsg[:], nil, sig) { + t.Fatal("FIPS 204 verifier rejected the EthDilithium signature " + + "on the Keccak-derived effective message β€” the wire format " + + "is supposed to be ML-DSA-65 standard, only the bound payload " + + "differs") + } +} + +// TestVerifyRejectsTamperedSig flips one byte of the signature and +// asserts Verify returns false. Negative test for the headline +// path. +func TestVerifyRejectsTamperedSig(t *testing.T) { + seed := bytes.Repeat([]byte{0xE9}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + msg := []byte("tamper") + ctx := []byte("LUX/test/tamper") + sig, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + t.Fatalf("Sign: %v", err) + } + + // Tamper inside c~ (first 48 bytes of sig). + bad := append([]byte{}, sig...) + bad[3] ^= 0x10 + if Verify(pk.Bytes(), msg, ctx, bad) { + t.Fatal("Verify accepted a tampered signature") + } + + // Tamper with the message: same sig, different msg, must reject. + if Verify(pk.Bytes(), []byte("tampered msg"), ctx, sig) { + t.Fatal("Verify accepted under a different message") + } + + // Tamper with ctx: must reject (ctx is bound into the Keccak prefix). + if Verify(pk.Bytes(), msg, []byte("LUX/test/tamper-other"), sig) { + t.Fatal("Verify accepted under a different context") + } +} + +// TestVerifyRejectsBadSizes covers each of the three size-mismatch +// rejection paths. +func TestVerifyRejectsBadSizes(t *testing.T) { + good := bytes.Repeat([]byte{0xAA}, PublicKeySize) + sigOk := bytes.Repeat([]byte{0xBB}, SignatureSize) + + if Verify(good[:PublicKeySize-1], nil, nil, sigOk) { + t.Error("accepted short pk") + } + if Verify(good, nil, nil, sigOk[:SignatureSize-1]) { + t.Error("accepted short sig") + } + longCtx := make([]byte, 256) + if Verify(good, nil, longCtx, sigOk) { + t.Error("accepted 256-byte ctx") + } +} + +// TestSignRejectsBadSizes covers the sign-side size checks. +func TestSignRejectsBadSizes(t *testing.T) { + if _, err := Sign(make([]byte, PrivateKeySize-1), nil, nil); err == nil { + t.Error("Sign accepted short sk") + } + longCtx := make([]byte, 256) + if _, err := Sign(make([]byte, PrivateKeySize), nil, longCtx); err == nil { + t.Error("Sign accepted 256-byte ctx") + } +} + +// TestDeterministicSign asserts two Sign calls on the same input +// produce byte-identical signatures (we route through +// mldsa65.Sign(..., randomized=false) under the hood). +func TestDeterministicSign(t *testing.T) { + seed := bytes.Repeat([]byte{0xEA}, mldsa65.SeedSize) + _, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + msg := []byte("determinism check") + ctx := []byte("LUX/test/determinism") + + sig1, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + t.Fatalf("Sign #1: %v", err) + } + sig2, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + t.Fatalf("Sign #2: %v", err) + } + if !bytes.Equal(sig1, sig2) { + t.Fatal("EthDilithium Sign is not deterministic on identical inputs") + } +} + +// TestKeccakBindingPrefixLength confirms the (ctx, msg) split is +// unambiguous: (ctx="AB", msg="C") MUST produce a different +// effective message than (ctx="A", msg="BC"). Without the +// length-prefix byte, the two would Keccak-collide. +func TestKeccakBindingPrefixLength(t *testing.T) { + a := keccakEffectiveMessage([]byte("C"), []byte("AB")) + b := keccakEffectiveMessage([]byte("BC"), []byte("A")) + if a == b { + t.Fatal("(ctx=AB,msg=C) and (ctx=A,msg=BC) produced the same effMsg " + + "β€” length-prefix is not preventing the boundary collision") + } +} + +// TestStrictPathLabel is a compile-time-ish check that the doc.go +// preamble names the strict path correctly. If someone renames +// the strict package without updating this test's expected string, +// the test fails β€” keeping the documentation honest. +func TestStrictPathLabel(t *testing.T) { + // mldsa65 must remain the FIPS 204 canonical Level 3 entry. + if mldsa65.SignatureSize != SignatureSize { + t.Errorf("EthDilithium-compat must wrap mldsa65: SignatureSize mismatch") + } + if mldsa65.PublicKeySize != PublicKeySize { + t.Errorf("EthDilithium-compat must wrap mldsa65: PublicKeySize mismatch") + } +} + +// BenchmarkSign measures the EthDilithium Sign throughput. The +// expected delta vs the canonical FIPS 204 sign is one extra +// Keccak-256 invocation per call β€” dominated by the ML-DSA cost, +// so the two should be close. +func BenchmarkSign(b *testing.B) { + seed := bytes.Repeat([]byte{0xEB}, mldsa65.SeedSize) + _, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + b.Fatalf("NewKeyFromSeed: %v", err) + } + skBytes := sk.Bytes() + msg := bytes.Repeat([]byte{0x33}, 256) + ctx := []byte("LUX/bench/ethcompat") + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, err := Sign(skBytes, msg, ctx); err != nil { + b.Fatalf("Sign: %v", err) + } + } +} + +// BenchmarkVerify measures the EthDilithium Verify throughput. +func BenchmarkVerify(b *testing.B) { + seed := bytes.Repeat([]byte{0xEB}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + b.Fatalf("NewKeyFromSeed: %v", err) + } + pkBytes := pk.Bytes() + msg := bytes.Repeat([]byte{0x33}, 256) + ctx := []byte("LUX/bench/ethcompat") + sig, err := Sign(sk.Bytes(), msg, ctx) + if err != nil { + b.Fatalf("Sign: %v", err) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + if !Verify(pkBytes, msg, ctx, sig) { + b.Fatal("verify failed mid-bench") + } + } +} diff --git a/pq/mldsa/expanded/derive.go b/pq/mldsa/expanded/derive.go new file mode 100644 index 0000000..6f0a70f --- /dev/null +++ b/pq/mldsa/expanded/derive.go @@ -0,0 +1,177 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package expanded + +import ( + "golang.org/x/crypto/sha3" +) + +// FIPS 204 polynomial constants for every ML-DSA parameter set. +const ( + // polyN is the degree-bound N of every ML-DSA polynomial. + polyN = 256 + + // polyQ is the prime modulus q = 2Β²Β³ βˆ’ 2ΒΉΒ³ + 1 = 8 380 417. + polyQ uint32 = 8380417 + + // polyCoeffMask masks the 23-bit coefficient sample drawn from + // the SHAKE-128 squeeze; samples β‰₯ polyQ are rejected (FIPS 204 + // Β§3.6.3 RejNTTPoly). + polyCoeffMask uint32 = 0x7fffff + + // polyPackedSize is the byte length of a single 23-bit-packed + // polynomial: ⌈N Β· 23 / 8βŒ‰ = 736 bytes (exact, no padding). + polyPackedSize = (polyN * 23) / 8 + + // shake128Rate is the SHAKE-128 output rate in bytes. + shake128Rate = 168 +) + +// deriveExpandedA fills dst with the byte-packed FIPS 204 Β§3.6.3 +// matrix A derived from rho for a KΓ—L parameter set. +// +// The on-wire layout is row-major: +// +// A[0,0] || A[0,1] || ... || A[0,L-1] +// A[1,0] || ... +// ... +// A[K-1,0] || ... || A[K-1,L-1] +// +// where each A[i,j] is one polynomial of N=256 23-bit-packed +// coefficients (polyPackedSize = 736 bytes). Total length is +// K * L * polyPackedSize and must equal len(dst). +// +// The polynomial at (i,j) is sampled from SHAKE-128 keyed by +// (rho β€– nonce_le16) where nonce = (i<<8) | j β€” matching the FIPS 204 +// ExpandA construction and the encoding used by CIRCL's internal +// verifier so the two derivations produce identical coefficients. +// +// Coefficients are stored as little-endian uint32 < polyQ, packed at +// 23 bits each (so 8 coefficients fit in 23 bytes β€” see packCoeffs). +func deriveExpandedA(dst []byte, rho *[32]byte, k, l int) { + var poly [polyN]uint32 + off := 0 + for i := 0; i < k; i++ { + for j := 0; j < l; j++ { + nonce := uint16(i<<8) | uint16(j) + rejSampleNTTPoly(&poly, rho, nonce) + packCoeffs(dst[off:off+polyPackedSize], &poly) + off += polyPackedSize + } + } +} + +// rejSampleNTTPoly implements FIPS 204 Algorithm 32 RejNTTPoly: it +// draws SHAKE-128 output keyed by (rho β€– nonce_le16) and accepts +// each 23-bit group < q as one polynomial coefficient, rejecting +// otherwise, until N coefficients are accepted. +// +// The construction is equivalent to CIRCL's PolyDeriveUniform with +// the SHAKE-128 rate of 168 bytes; we re-derive coefficients here +// independently of CIRCL's internal API. +func rejSampleNTTPoly(p *[polyN]uint32, rho *[32]byte, nonce uint16) { + var iv [34]byte + copy(iv[:32], rho[:]) + iv[32] = byte(nonce) + iv[33] = byte(nonce >> 8) + + h := sha3.NewShake128() + _, _ = h.Write(iv[:]) + + var buf [shake128Rate]byte + idx := 0 + for idx < polyN { + _, _ = h.Read(buf[:]) + // Three squeezed bytes -> one 24-bit little-endian word -> + // mask to 23 bits -> accept iff < q. 168 / 3 = 56 trials per + // squeezed block; the rate is divisible by 3 so we never + // straddle a refill boundary. + for off := 0; off+3 <= shake128Rate && idx < polyN; off += 3 { + t := uint32(buf[off]) | + (uint32(buf[off+1]) << 8) | + (uint32(buf[off+2]) << 16) + t &= polyCoeffMask + if t < polyQ { + p[idx] = t + idx++ + } + } + } +} + +// packCoeffs serializes 256 23-bit coefficients into 736 bytes, +// little-endian, bit-packed contiguously (no padding between +// coefficients). It is the inverse of unpackCoeffs (used by tests). +// +// The encoding is canonical: identical inputs always produce +// identical outputs, byte-for-byte, on every platform. This is what +// makes the expanded form usable as a fingerprintable cache. +func packCoeffs(dst []byte, p *[polyN]uint32) { + // Group of 8 coefficients = 8 Γ— 23 = 184 bits = 23 bytes. + // 256 / 8 = 32 groups, 32 Γ— 23 = 736 bytes. + for g := 0; g < polyN/8; g++ { + c := p[g*8 : g*8+8] + out := dst[g*23 : g*23+23] + // Pack c[0..7] into a 64-bit + 64-bit + 64-bit accumulator + // pair, then peel off bytes. We use straightforward shifts + // rather than a clever 184-bit big-integer multiply. + var acc [3]uint64 + acc[0] = uint64(c[0]) | + (uint64(c[1]) << 23) | + (uint64(c[2]) << 46) + // c[2] occupies bits 46..68; high 5 bits spill into acc[1]. + acc[1] = uint64(c[2])>>(64-46) | + (uint64(c[3]) << (69 - 64)) | + (uint64(c[4]) << (92 - 64)) | + (uint64(c[5]) << (115 - 64)) + // c[5] occupies bits 115..137; high 13 bits spill into acc[2]. + acc[2] = uint64(c[5])>>(128-115) | + (uint64(c[6]) << (138 - 128)) | + (uint64(c[7]) << (161 - 128)) + + // Emit 23 bytes little-endian, drawn from the three 64-bit + // limbs. Bytes 0..7 from acc[0], 8..15 from acc[1], 16..22 + // from acc[2] (only 7 bytes β€” bit 184 is exactly past the + // end of c[7], so byte 22 contains the top 8 bits of c[7]). + for b := 0; b < 8; b++ { + out[b] = byte(acc[0] >> (8 * b)) + } + for b := 0; b < 8; b++ { + out[8+b] = byte(acc[1] >> (8 * b)) + } + for b := 0; b < 7; b++ { + out[16+b] = byte(acc[2] >> (8 * b)) + } + } +} + +// unpackCoeffs inverts packCoeffs. It is used in tests to confirm +// the pack is lossless and to compare two derivations coefficient- +// by-coefficient. +func unpackCoeffs(p *[polyN]uint32, src []byte) { + for g := 0; g < polyN/8; g++ { + in := src[g*23 : g*23+23] + out := p[g*8 : g*8+8] + + var acc [3]uint64 + for b := 0; b < 8; b++ { + acc[0] |= uint64(in[b]) << (8 * b) + } + for b := 0; b < 8; b++ { + acc[1] |= uint64(in[8+b]) << (8 * b) + } + for b := 0; b < 7; b++ { + acc[2] |= uint64(in[16+b]) << (8 * b) + } + + out[0] = uint32(acc[0]) & polyCoeffMask + out[1] = uint32(acc[0]>>23) & polyCoeffMask + out[2] = uint32((acc[0]>>46)|(acc[1]<<18)) & polyCoeffMask + out[3] = uint32(acc[1]>>(69-64)) & polyCoeffMask + out[4] = uint32(acc[1]>>(92-64)) & polyCoeffMask + out[5] = uint32((acc[1]>>(115-64))|(acc[2]<<(128-115))) & polyCoeffMask + out[6] = uint32(acc[2]>>(138-128)) & polyCoeffMask + out[7] = uint32(acc[2]>>(161-128)) & polyCoeffMask + } +} diff --git a/pq/mldsa/expanded/doc.go b/pq/mldsa/expanded/doc.go new file mode 100644 index 0000000..56933e9 --- /dev/null +++ b/pq/mldsa/expanded/doc.go @@ -0,0 +1,45 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Package expanded implements the EIP-8051 expanded-public-key form +// for ML-DSA, where the matrix A (FIPS 204 Β§3.6.3 ExpandA) is +// precomputed and carried alongside the compact (ρ β€– t1) public key. +// +// The expansion is deterministic and reproducible: given the compact +// public key bytes, ExpandedA is fully determined by the 32-byte ρ +// prefix and the parameter set (K, L). Re-expanding always yields the +// same byte sequence β€” this is what makes the form usable as a cache +// rather than a separate trust root. +// +// Layout for an ML-DSA-65 expanded key: +// +// Compact : 1952 bytes β€” FIPS 204 Β§6.4 public-key encoding +// ExpandedA : K Γ— L Γ— N Γ— 23 bits, byte-packed +// = 6 Γ— 5 Γ— 256 Γ— 23 / 8 = 22,080 bytes +// +// The 23-bit packing matches the coefficient bound q βˆ’ 1 < 2Β²Β³ +// (FIPS 204 Β§3.4: q = 2Β²Β³ βˆ’ 2ΒΉΒ³ + 1 = 8 380 417). EIP-8051 quotes +// "~20,512 bytes" for the same security level using a slightly +// different in-memory layout; our serialization is canonical for the +// luxfi/crypto stack and round-trips losslessly. The same packing +// rule applies to ML-DSA-44 (K=4, L=4 β†’ 11,776 bytes) and ML-DSA-87 +// (K=8, L=7 β†’ 41,216 bytes); see the per-parameter Size constants. +// +// API surface: +// +// Expand(compact) (*PublicKey, error) β€” derive ExpandedA from ρ +// Compact(*PublicKey) []byte β€” drop ExpandedA, keep ρ β€– t1 +// Verify(*PublicKey, msg, ctx, sig) bool β€” variance-checked verify +// +// Verify cross-checks the carried ExpandedA against a fresh expansion +// (so a tampered cache cannot make a bad signature accept) and then +// delegates to the canonical FIPS 204 verifier in +// crypto/pq/mldsa/mldsa65. The cross-check is a byte comparison on +// the freshly-derived expansion and is independent of the upstream +// CIRCL verifier's own internal ExpandA call. +// +// This package is FIPS 204 conformant in the sense that Verify +// accepts iff the canonical FIPS 204 verifier accepts; it does not +// modify the wire signature format and it is not the variant +// described in crypto/pq/mldsa/ethdilithium_compat. +package expanded diff --git a/pq/mldsa/expanded/expanded.go b/pq/mldsa/expanded/expanded.go new file mode 100644 index 0000000..4596730 --- /dev/null +++ b/pq/mldsa/expanded/expanded.go @@ -0,0 +1,245 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package expanded + +import ( + "errors" + "fmt" + + "github.com/luxfi/crypto/pq/mldsa/mldsa44" + "github.com/luxfi/crypto/pq/mldsa/mldsa65" + "github.com/luxfi/crypto/pq/mldsa/mldsa87" +) + +// ParamSet identifies the FIPS 204 parameter set the expanded key is bound to. +// The wire byte layouts are not interchangeable across sets; ParamSet is +// stored in PublicKey so a misrouted Verify call fails closed. +type ParamSet uint8 + +const ( + // MLDSA44 is the NIST Level 2 parameter set (K=4, L=4). + MLDSA44 ParamSet = 44 + // MLDSA65 is the NIST Level 3 parameter set (K=6, L=5). + MLDSA65 ParamSet = 65 + // MLDSA87 is the NIST Level 5 parameter set (K=8, L=7). + MLDSA87 ParamSet = 87 +) + +// String returns the canonical parameter-set label. +func (p ParamSet) String() string { + switch p { + case MLDSA44: + return "ML-DSA-44" + case MLDSA65: + return "ML-DSA-65" + case MLDSA87: + return "ML-DSA-87" + default: + return fmt.Sprintf("ML-DSA-?(%d)", p) + } +} + +// params returns the (K, L, compactSize, expandedASize) tuple for a set. +func (p ParamSet) params() (k, l, compactSize, expandedASize int, ok bool) { + switch p { + case MLDSA44: + return 4, 4, mldsa44.PublicKeySize, 4 * 4 * polyPackedSize, true + case MLDSA65: + return 6, 5, mldsa65.PublicKeySize, 6 * 5 * polyPackedSize, true + case MLDSA87: + return 8, 7, mldsa87.PublicKeySize, 8 * 7 * polyPackedSize, true + default: + return 0, 0, 0, 0, false + } +} + +// Size constants. ExpandedASize reports the number of bytes +// occupied by the precomputed matrix A for the named parameter set +// using the 23-bit packed encoding documented in doc.go. +const ( + ExpandedASize44 = 4 * 4 * polyPackedSize // 11,776 bytes + ExpandedASize65 = 6 * 5 * polyPackedSize // 22,080 bytes + ExpandedASize87 = 8 * 7 * polyPackedSize // 41,216 bytes +) + +// PublicKey is an EIP-8051-style expanded ML-DSA public key. +// +// Compact holds the FIPS 204 Β§6.4 encoding (ρ β€– t1) verbatim β€” i.e., +// the exact bytes a canonical mldsaXX.PublicKey serializes to. The +// 32-byte ρ prefix is also the seed that determines ExpandedA. +// +// ExpandedA holds the KΓ—L polynomials of the matrix A in NTT-domain, +// 23-bit packed (matching the coefficient bound q βˆ’ 1 < 2Β²Β³). It is +// fully recomputable from Compact[:32] (ρ); the field exists so that +// throughput-sensitive verifiers can amortize the SHAKE-128 expansion +// over many signatures. A nil/short ExpandedA is treated as "no +// cache present" and Expand() recomputes it. +type PublicKey struct { + Set ParamSet + Compact []byte + ExpandedA []byte +} + +// Common errors. They are returned, never panicked, even on +// malformed inputs β€” Verify is a boundary function. +var ( + // ErrUnknownParamSet is returned when Set is not 44/65/87. + ErrUnknownParamSet = errors.New("mldsa expanded: unknown parameter set") + // ErrCompactSize is returned when Compact has the wrong length for Set. + ErrCompactSize = errors.New("mldsa expanded: compact key size mismatch") + // ErrExpandedASize is returned when ExpandedA has the wrong length for Set. + ErrExpandedASize = errors.New("mldsa expanded: expanded-A size mismatch") + // ErrExpandedAMismatch is returned by Verify when the carried + // ExpandedA does not match the deterministic re-expansion of ρ. + // A caller seeing this error is holding a corrupted or + // tampered cache. + ErrExpandedAMismatch = errors.New("mldsa expanded: ExpandedA does not match ρ") +) + +// Expand returns the expanded form of an ML-DSA-XX compact public key. +// The parameter set is inferred from len(compact). +// +// The returned PublicKey owns a freshly-allocated ExpandedA derived +// from compact[:32] (ρ). The Compact field is a copy of the input. +func Expand(compact []byte) (*PublicKey, error) { + set, err := paramSetFromCompactSize(len(compact)) + if err != nil { + return nil, err + } + return ExpandSet(set, compact) +} + +// ExpandSet is the explicit-parameter-set form of Expand. It returns +// ErrCompactSize if len(compact) does not match Set. +func ExpandSet(set ParamSet, compact []byte) (*PublicKey, error) { + k, l, compactSize, expandedSize, ok := set.params() + if !ok { + return nil, ErrUnknownParamSet + } + if len(compact) != compactSize { + return nil, fmt.Errorf("%w: %s want %d, got %d", + ErrCompactSize, set, compactSize, len(compact)) + } + + pk := &PublicKey{ + Set: set, + Compact: append([]byte(nil), compact...), + ExpandedA: make([]byte, expandedSize), + } + var rho [32]byte + copy(rho[:], compact[:32]) + deriveExpandedA(pk.ExpandedA, &rho, k, l) + return pk, nil +} + +// Compact returns the canonical FIPS 204 Β§6.4 encoding of pk (ρ β€– t1). +// The returned slice is a copy; callers may mutate it without +// affecting pk. The ExpandedA cache is intentionally dropped β€” round- +// tripping through Compact() and Expand() is the documented way to +// shed a precomputed matrix from a serialized form. +func Compact(pk *PublicKey) []byte { + if pk == nil { + return nil + } + return append([]byte(nil), pk.Compact...) +} + +// Verify reports whether sig is a valid ML-DSA signature on (msg, ctx) +// under pk. It enforces three invariants in order: +// +// 1. pk.Set is one of MLDSA44/65/87. +// 2. len(pk.Compact) matches the wire size for pk.Set. +// 3. pk.ExpandedA, if present, matches a fresh re-expansion of ρ; +// a mismatch returns false (a tampered cache cannot bias verify). +// +// Once the cache check passes, Verify delegates to the canonical +// FIPS 204 verifier in crypto/pq/mldsa/mldsaXX. The cache is the +// optimization; the FIPS-204 path is the authority. +func Verify(pk *PublicKey, msg, ctx, sig []byte) bool { + if pk == nil { + return false + } + k, l, compactSize, expandedSize, ok := pk.Set.params() + if !ok { + return false + } + if len(pk.Compact) != compactSize { + return false + } + if pk.ExpandedA != nil { + if len(pk.ExpandedA) != expandedSize { + return false + } + var rho [32]byte + copy(rho[:], pk.Compact[:32]) + fresh := make([]byte, expandedSize) + deriveExpandedA(fresh, &rho, k, l) + if !bytesEqual(fresh, pk.ExpandedA) { + return false + } + } + return verifyCompact(pk.Set, pk.Compact, msg, ctx, sig) +} + +// verifyCompact wraps the per-parameter-set canonical verifier so +// Verify can dispatch on Set without importing the typed key in this +// file's API surface. +func verifyCompact(set ParamSet, compact, msg, ctx, sig []byte) bool { + switch set { + case MLDSA44: + var raw [mldsa44.PublicKeySize]byte + copy(raw[:], compact) + var pk mldsa44.PublicKey + pk.Unpack(&raw) + return mldsa44.Verify(&pk, msg, ctx, sig) + case MLDSA65: + var raw [mldsa65.PublicKeySize]byte + copy(raw[:], compact) + var pk mldsa65.PublicKey + pk.Unpack(&raw) + return mldsa65.Verify(&pk, msg, ctx, sig) + case MLDSA87: + var raw [mldsa87.PublicKeySize]byte + copy(raw[:], compact) + var pk mldsa87.PublicKey + pk.Unpack(&raw) + return mldsa87.Verify(&pk, msg, ctx, sig) + default: + return false + } +} + +// paramSetFromCompactSize maps a compact-key length to its parameter +// set. The three FIPS 204 sizes are distinct, so the mapping is +// unambiguous. +func paramSetFromCompactSize(n int) (ParamSet, error) { + switch n { + case mldsa44.PublicKeySize: + return MLDSA44, nil + case mldsa65.PublicKeySize: + return MLDSA65, nil + case mldsa87.PublicKeySize: + return MLDSA87, nil + default: + return 0, fmt.Errorf("%w: unrecognized compact size %d", + ErrCompactSize, n) + } +} + +// bytesEqual is constant-time at the byte level for our fixed-size +// cache comparison. We don't need full constant-time semantics here +// (the cache contents are public, derived from ρ which is itself +// public), but a straight bytes.Equal is fine and we avoid the +// stdlib import dependency. +func bytesEqual(a, b []byte) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i] != b[i] { + return false + } + } + return true +} diff --git a/pq/mldsa/expanded/expanded_test.go b/pq/mldsa/expanded/expanded_test.go new file mode 100644 index 0000000..1a5a05c --- /dev/null +++ b/pq/mldsa/expanded/expanded_test.go @@ -0,0 +1,491 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package expanded + +import ( + "bytes" + "testing" + + "github.com/luxfi/crypto/pq/mldsa/mldsa44" + "github.com/luxfi/crypto/pq/mldsa/mldsa65" + "github.com/luxfi/crypto/pq/mldsa/mldsa87" +) + +// TestSizeConstants pins the wire layout sizes. If these values +// change, EVERY persisted expanded key on the network goes invalid β€” +// so the constants are deliberately spelled out as integer literals +// matching the documentation in doc.go and a regression here is +// almost certainly a bug. +func TestSizeConstants(t *testing.T) { + cases := []struct { + set ParamSet + expected int + }{ + {MLDSA44, 11776}, + {MLDSA65, 22080}, + {MLDSA87, 41216}, + } + for _, tc := range cases { + _, _, _, got, ok := tc.set.params() + if !ok { + t.Fatalf("%s: params() returned !ok", tc.set) + } + if got != tc.expected { + t.Errorf("%s: ExpandedASize=%d want %d", tc.set, got, tc.expected) + } + } + + // Cross-check the named constants match. + if ExpandedASize44 != 11776 { + t.Errorf("ExpandedASize44 = %d", ExpandedASize44) + } + if ExpandedASize65 != 22080 { + t.Errorf("ExpandedASize65 = %d", ExpandedASize65) + } + if ExpandedASize87 != 41216 { + t.Errorf("ExpandedASize87 = %d", ExpandedASize87) + } +} + +// TestPackRoundTrip confirms the 23-bit pack/unpack pair is +// lossless: every input coefficient < q survives a pack-then-unpack +// trip unchanged. +func TestPackRoundTrip(t *testing.T) { + // A non-trivial test vector: increasing coefficients near 0 and + // near q so we exercise the high bits of c[i] as well as the + // inter-coefficient byte boundaries. + var in [polyN]uint32 + for i := 0; i < polyN; i++ { + // Deterministic, spread across the valid range. + in[i] = uint32(i*131) % polyQ + } + var packed [polyPackedSize]byte + packCoeffs(packed[:], &in) + + var out [polyN]uint32 + unpackCoeffs(&out, packed[:]) + + for i := 0; i < polyN; i++ { + if in[i] != out[i] { + t.Fatalf("pack/unpack: coeff %d: in=%d out=%d", i, in[i], out[i]) + } + } +} + +// TestPackBoundary verifies pack/unpack on the extreme corners of +// the coefficient range: 0, 1, qβˆ’1. qβˆ’1 is the largest representable +// coefficient and exercises every bit position. +func TestPackBoundary(t *testing.T) { + var in [polyN]uint32 + for i := 0; i < polyN; i++ { + switch i % 3 { + case 0: + in[i] = 0 + case 1: + in[i] = 1 + case 2: + in[i] = polyQ - 1 + } + } + var packed [polyPackedSize]byte + packCoeffs(packed[:], &in) + var out [polyN]uint32 + unpackCoeffs(&out, packed[:]) + for i := 0; i < polyN; i++ { + if in[i] != out[i] { + t.Fatalf("boundary coeff %d: in=%d out=%d", i, in[i], out[i]) + } + } +} + +// TestRejSampleDeterministic confirms two independent calls with the +// same (rho, nonce) produce byte-identical polynomial coefficients β€” +// the headline property the expanded-form cache relies on. +func TestRejSampleDeterministic(t *testing.T) { + var rho [32]byte + for i := range rho { + rho[i] = byte(i * 7) + } + var p1, p2 [polyN]uint32 + rejSampleNTTPoly(&p1, &rho, 0x0102) + rejSampleNTTPoly(&p2, &rho, 0x0102) + for i := 0; i < polyN; i++ { + if p1[i] != p2[i] { + t.Fatalf("nondeterministic: coeff %d differs (%d vs %d)", i, p1[i], p2[i]) + } + if p1[i] >= polyQ { + t.Fatalf("coeff %d = %d exceeds q=%d (rejection sampling broken)", + i, p1[i], polyQ) + } + } +} + +// TestRejSampleNonceSeparation confirms swapping i and j (i.e. +// changing the nonce from (i<<8)|j to (j<<8)|i) yields a different +// polynomial β€” without this, the matrix would have repeated rows or +// transposed entries. +func TestRejSampleNonceSeparation(t *testing.T) { + var rho [32]byte + for i := range rho { + rho[i] = 0xA5 + } + var p1, p2 [polyN]uint32 + rejSampleNTTPoly(&p1, &rho, (1<<8)|2) + rejSampleNTTPoly(&p2, &rho, (2<<8)|1) + same := true + for i := 0; i < polyN; i++ { + if p1[i] != p2[i] { + same = false + break + } + } + if same { + t.Fatal("nonce (1<<8)|2 and (2<<8)|1 produced identical polynomials") + } +} + +// TestExpandSet_MLDSA65 exercises the headline path: take a real +// FIPS 204 compact key, expand it, confirm sizes, confirm the +// Compact field is the input verbatim (defensive copy aside). +func TestExpandSet_MLDSA65(t *testing.T) { + seed := bytes.Repeat([]byte{0x42}, mldsa65.SeedSize) + pk, _, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + compact := pk.Bytes() + if len(compact) != mldsa65.PublicKeySize { + t.Fatalf("compact size: got %d, want %d", len(compact), mldsa65.PublicKeySize) + } + + exp, err := ExpandSet(MLDSA65, compact) + if err != nil { + t.Fatalf("ExpandSet: %v", err) + } + if exp.Set != MLDSA65 { + t.Errorf("Set: got %v want MLDSA65", exp.Set) + } + if !bytes.Equal(exp.Compact, compact) { + t.Error("Compact field differs from input") + } + if len(exp.ExpandedA) != ExpandedASize65 { + t.Errorf("ExpandedA size: got %d want %d", len(exp.ExpandedA), ExpandedASize65) + } + + // Confirm the defensive copy: mutating compact must NOT mutate exp.Compact. + saved := exp.Compact[0] + compact[0] ^= 0xFF + if exp.Compact[0] != saved { + t.Error("ExpandSet did not copy compact (input mutation propagates)") + } +} + +// TestExpand_AutoParamDetection verifies that Expand (no explicit +// set) routes to the right parameter set based on input length. +func TestExpand_AutoParamDetection(t *testing.T) { + cases := []struct { + name string + size int + set ParamSet + }{ + {"mldsa44", mldsa44.PublicKeySize, MLDSA44}, + {"mldsa65", mldsa65.PublicKeySize, MLDSA65}, + {"mldsa87", mldsa87.PublicKeySize, MLDSA87}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + compact := make([]byte, tc.size) + for i := range compact[:32] { + compact[i] = byte(i ^ int(tc.set)) + } + exp, err := Expand(compact) + if err != nil { + t.Fatalf("Expand: %v", err) + } + if exp.Set != tc.set { + t.Errorf("inferred set: got %v want %v", exp.Set, tc.set) + } + }) + } +} + +// TestExpand_RoundTrip is the headline property: Expand(Compact(Expand(x))) +// agrees byte-for-byte with Expand(x). Compact() must drop ExpandedA +// (per spec), so we re-derive on the second pass and compare. +func TestExpand_RoundTrip(t *testing.T) { + seed := bytes.Repeat([]byte{0xC3}, mldsa65.SeedSize) + pk, _, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + exp1, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand #1: %v", err) + } + compact := Compact(exp1) + exp2, err := Expand(compact) + if err != nil { + t.Fatalf("Expand #2: %v", err) + } + + if exp1.Set != exp2.Set { + t.Errorf("Set differs across round-trip: %v vs %v", exp1.Set, exp2.Set) + } + if !bytes.Equal(exp1.Compact, exp2.Compact) { + t.Error("Compact differs across round-trip") + } + if !bytes.Equal(exp1.ExpandedA, exp2.ExpandedA) { + t.Error("ExpandedA differs across round-trip β€” derivation is not deterministic") + } +} + +// TestExpandedVerify_MatchesCompactVerify confirms a synthetic key +// + signature verifies equivalently under (a) the canonical FIPS 204 +// path in mldsa65.Verify and (b) the expanded-form Verify here. The +// two MUST agree for every signature; disagreement means the +// expanded path has introduced an oracle. +func TestExpandedVerify_MatchesCompactVerify(t *testing.T) { + seed := bytes.Repeat([]byte{0x77}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + msg := []byte("expanded vs compact verifier parity") + ctx := []byte("LUX/test/expanded") + sig, err := mldsa65.Sign(sk, msg, ctx, false) + if err != nil { + t.Fatalf("Sign: %v", err) + } + + if !mldsa65.Verify(pk, msg, ctx, sig) { + t.Fatal("compact Verify rejected its own signature") + } + + exp, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand: %v", err) + } + if !Verify(exp, msg, ctx, sig) { + t.Fatal("expanded Verify rejected a signature compact Verify accepts") + } +} + +// TestExpandedVerify_RejectsTamperedSig flips one byte of the +// signature and asserts both verifiers (compact + expanded) reject. +func TestExpandedVerify_RejectsTamperedSig(t *testing.T) { + seed := bytes.Repeat([]byte{0x11}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + msg := []byte("tampered sig must reject") + ctx := []byte("LUX/test/expanded-tamper") + sig, err := mldsa65.Sign(sk, msg, ctx, false) + if err != nil { + t.Fatalf("Sign: %v", err) + } + sig[7] ^= 0x01 + + if mldsa65.Verify(pk, msg, ctx, sig) { + t.Fatal("compact Verify accepted tampered sig (test setup broken)") + } + exp, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand: %v", err) + } + if Verify(exp, msg, ctx, sig) { + t.Fatal("expanded Verify accepted a tampered signature") + } +} + +// TestExpandedVerify_RejectsTamperedCache flips one byte of +// ExpandedA and asserts Verify rejects (the cache-integrity check +// must prevent an attacker-supplied A from biasing verification). +func TestExpandedVerify_RejectsTamperedCache(t *testing.T) { + seed := bytes.Repeat([]byte{0x99}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + msg := []byte("tampered cache must reject") + ctx := []byte("LUX/test/expanded-cache-tamper") + sig, err := mldsa65.Sign(sk, msg, ctx, false) + if err != nil { + t.Fatalf("Sign: %v", err) + } + + exp, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand: %v", err) + } + // Sanity: legit expanded form accepts. + if !Verify(exp, msg, ctx, sig) { + t.Fatal("baseline expanded Verify rejected a legitimate signature") + } + // Flip one bit deep inside ExpandedA. + exp.ExpandedA[5000] ^= 0x80 + if Verify(exp, msg, ctx, sig) { + t.Fatal("expanded Verify accepted a key with tampered ExpandedA cache") + } +} + +// TestExpandedVerify_RejectsSizeMismatch asserts a Compact field +// with the wrong length is refused without crashing. +func TestExpandedVerify_RejectsSizeMismatch(t *testing.T) { + exp := &PublicKey{ + Set: MLDSA65, + Compact: make([]byte, mldsa65.PublicKeySize-1), + } + if Verify(exp, []byte("x"), nil, make([]byte, mldsa65.SignatureSize)) { + t.Fatal("Verify accepted a short Compact") + } +} + +// TestExpandSet_RejectsUnknownSet pins the error path. +func TestExpandSet_RejectsUnknownSet(t *testing.T) { + if _, err := ExpandSet(ParamSet(99), make([]byte, 1000)); err == nil { + t.Fatal("ExpandSet accepted unknown parameter set") + } +} + +// TestExpand_RejectsBadSize confirms a length that does not match +// any FIPS 204 parameter set is rejected by Expand. +func TestExpand_RejectsBadSize(t *testing.T) { + if _, err := Expand(make([]byte, 100)); err == nil { + t.Fatal("Expand accepted a 100-byte input (no parameter set has this size)") + } +} + +// TestCompactNilSafe asserts Compact(nil) returns nil, not panic. +func TestCompactNilSafe(t *testing.T) { + if b := Compact(nil); b != nil { + t.Errorf("Compact(nil) = %v, want nil", b) + } +} + +// TestVerifyNilSafe asserts Verify(nil, ...) returns false, not panic. +func TestVerifyNilSafe(t *testing.T) { + if Verify(nil, []byte("x"), nil, []byte("y")) { + t.Fatal("Verify(nil) returned true") + } +} + +// TestExpand_AllParamSets exercises expand+verify on all three +// parameter sets so a regression in any one is caught here. +func TestExpand_AllParamSets(t *testing.T) { + t.Run("MLDSA44", func(t *testing.T) { + seed := bytes.Repeat([]byte{0x44}, mldsa44.SeedSize) + pk, sk, err := mldsa44.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + sig, err := mldsa44.Sign(sk, []byte("m"), []byte("c"), false) + if err != nil { + t.Fatalf("Sign: %v", err) + } + exp, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand: %v", err) + } + if exp.Set != MLDSA44 { + t.Errorf("Set: got %v want MLDSA44", exp.Set) + } + if !Verify(exp, []byte("m"), []byte("c"), sig) { + t.Fatal("MLDSA44 expanded Verify failed") + } + }) + t.Run("MLDSA87", func(t *testing.T) { + seed := bytes.Repeat([]byte{0x87}, mldsa87.SeedSize) + pk, sk, err := mldsa87.NewKeyFromSeed(seed) + if err != nil { + t.Fatalf("NewKeyFromSeed: %v", err) + } + sig, err := mldsa87.Sign(sk, []byte("m"), []byte("c"), false) + if err != nil { + t.Fatalf("Sign: %v", err) + } + exp, err := Expand(pk.Bytes()) + if err != nil { + t.Fatalf("Expand: %v", err) + } + if exp.Set != MLDSA87 { + t.Errorf("Set: got %v want MLDSA87", exp.Set) + } + if !Verify(exp, []byte("m"), []byte("c"), sig) { + t.Fatal("MLDSA87 expanded Verify failed") + } + }) +} + +// BenchmarkVerifyCompact is the baseline: vanilla mldsa65.Verify on +// a fixed (pk, msg, sig). Compare against BenchmarkVerifyExpanded +// to read the overhead/savings of the expanded path. +func BenchmarkVerifyCompact(b *testing.B) { + seed := bytes.Repeat([]byte{0xBB}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + b.Fatalf("NewKeyFromSeed: %v", err) + } + msg := bytes.Repeat([]byte{0x33}, 256) + ctx := []byte("LUX/bench/mldsa65/compact") + sig, err := mldsa65.Sign(sk, msg, ctx, false) + if err != nil { + b.Fatalf("Sign: %v", err) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + if !mldsa65.Verify(pk, msg, ctx, sig) { + b.Fatal("verify failed mid-bench") + } + } +} + +// BenchmarkVerifyExpanded measures the expanded-form Verify which +// pays for the integrity re-derivation of A on each call. With +// CIRCL's internal API still hidden, the expanded path is strictly +// slower than the compact path for a single verification; the win +// shows up only when a downstream verifier consumes the pre-derived +// A directly. Until that's wired, the benchmark exists as a true +// floor on the throughput cost of the integrity check. +func BenchmarkVerifyExpanded(b *testing.B) { + seed := bytes.Repeat([]byte{0xBB}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + b.Fatalf("NewKeyFromSeed: %v", err) + } + msg := bytes.Repeat([]byte{0x33}, 256) + ctx := []byte("LUX/bench/mldsa65/expanded") + sig, err := mldsa65.Sign(sk, msg, ctx, false) + if err != nil { + b.Fatalf("Sign: %v", err) + } + exp, err := Expand(pk.Bytes()) + if err != nil { + b.Fatalf("Expand: %v", err) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + if !Verify(exp, msg, ctx, sig) { + b.Fatal("verify failed mid-bench") + } + } +} + +// BenchmarkExpand measures the one-time cost of building an +// expanded form from a compact key. This is the cost amortized +// across many verifications when the expanded form is cached. +func BenchmarkExpand(b *testing.B) { + seed := bytes.Repeat([]byte{0xBB}, mldsa65.SeedSize) + pk, _, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + b.Fatalf("NewKeyFromSeed: %v", err) + } + compact := pk.Bytes() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, err := Expand(compact); err != nil { + b.Fatalf("Expand: %v", err) + } + } +} diff --git a/pq/mldsa/kats/doc.go b/pq/mldsa/kats/doc.go new file mode 100644 index 0000000..b7e66db --- /dev/null +++ b/pq/mldsa/kats/doc.go @@ -0,0 +1,37 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Package kats implements Known-Answer-Test (KAT) regression +// vectors for the FIPS 204 ML-DSA-44 / ML-DSA-65 / ML-DSA-87 +// parameter sets as wrapped by crypto/pq/mldsa. +// +// Each parameter set has a slice of pinned Vector records of the +// form (Seed, Msg, Ctx, PublicKey, PrivateKey, Signature). At test +// time, every vector is re-derived from its Seed via +// mldsaXX.NewKeyFromSeed and mldsaXX.Sign(..., randomized=false), +// then compared byte-for-byte against the pinned record. A +// mismatch is a regression in the deterministic-keygen or +// deterministic-sign path. +// +// # Origin +// +// FIPS 204 was finalized August 2024. NIST's ACVP-Server publishes +// a JSON test-vector battery (keyGen / sigGen / sigVer) that CIRCL, +// the upstream we delegate to, already runs against in its own +// test suite β€” those vectors are not redistributed here. +// +// The vectors in this package are SYNTHETIC: they are produced +// deterministically by the same code paths under test, pinned by +// hand, and serve as a regression tripwire β€” the test asserts that +// the bytes do not move silently between releases. Replace these +// vectors with official NIST CAVS .rsp files when those are +// published in a form suitable for direct ingestion. +// +// # Discipline +// +// The generator (kats/internal/gen) writes the same Go source the +// tests load. Running it twice produces byte-identical output, so a +// `go run ./pq/mldsa/kats/internal/gen` invocation that produces a +// diff is itself the regression signal. The Makefile target +// `make gen_kats` exposes this. +package kats diff --git a/pq/mldsa/kats/internal/gen/main.go b/pq/mldsa/kats/internal/gen/main.go new file mode 100644 index 0000000..906c451 --- /dev/null +++ b/pq/mldsa/kats/internal/gen/main.go @@ -0,0 +1,218 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// gen produces the pinned KAT vector files (vectors_mldsa{44,65,87}.go) +// consumed by package kats. Invocation: +// +// go run github.com/luxfi/crypto/pq/mldsa/kats/internal/gen +// +// The generated source is deterministic β€” the same fixed seeds in +// the same order produce byte-identical output on every run, on +// every architecture. The Makefile target `make gen_kats` invokes +// this binary then re-runs the test suite to confirm the freshly- +// written vectors still pass. +package main + +import ( + "bytes" + "flag" + "fmt" + "go/format" + "os" + "path/filepath" + "strings" + + "github.com/luxfi/crypto/pq/mldsa/mldsa44" + "github.com/luxfi/crypto/pq/mldsa/mldsa65" + "github.com/luxfi/crypto/pq/mldsa/mldsa87" +) + +// vectorSpec is the input recipe for one KAT vector. A spec is +// deterministically reduced to a Vector by running it through the +// per-parameter-set NewKeyFromSeed + Sign code paths. +type vectorSpec struct { + seedByte byte // every byte of the 32-byte ΞΎ is set to seedByte + msg string // message under test (string lit for readability) + ctx string // domain-separation context; "" means nil ctx +} + +// specs lists the synthetic KAT recipes shared across all three +// parameter sets. The order is meaningful (Count = index) and MUST +// NOT be reordered without regenerating the pinned files. +var specs = []vectorSpec{ + {0x00, "", ""}, + {0xFF, "FIPS204 KAT all-ones seed", "LUX/KAT/v1"}, + {0x42, "deterministic ML-DSA signature", ""}, + {0xA5, "context-bound signature", "LUX/KAT/ctx/v1"}, + {0x5A, "long message" + strings.Repeat("/", 64), "LUX/KAT/longmsg/v1"}, +} + +func main() { + out := flag.String("out", "", "output directory (default: package dir of kats)") + flag.Parse() + + outDir := *out + if outDir == "" { + // Resolve relative to this generator's source file. + // CWD at `go run` time = caller's CWD, so default to + // the canonical relative path from the repo root. + outDir = "pq/mldsa/kats" + } + if err := os.MkdirAll(outDir, 0o755); err != nil { + die("mkdir %s: %v", outDir, err) + } + + if err := genMLDSA44(filepath.Join(outDir, "vectors_mldsa44.go")); err != nil { + die("mldsa44: %v", err) + } + if err := genMLDSA65(filepath.Join(outDir, "vectors_mldsa65.go")); err != nil { + die("mldsa65: %v", err) + } + if err := genMLDSA87(filepath.Join(outDir, "vectors_mldsa87.go")); err != nil { + die("mldsa87: %v", err) + } +} + +func genMLDSA44(path string) error { + var buf bytes.Buffer + writeHeader(&buf, "mldsa44", "ML-DSA-44 (NIST Level 2)") + for i, s := range specs { + seed := bytes.Repeat([]byte{s.seedByte}, mldsa44.SeedSize) + pk, sk, err := mldsa44.NewKeyFromSeed(seed) + if err != nil { + return fmt.Errorf("spec %d NewKeyFromSeed: %w", i, err) + } + var ctx []byte + if s.ctx != "" { + ctx = []byte(s.ctx) + } + sig, err := mldsa44.Sign(sk, []byte(s.msg), ctx, false) + if err != nil { + return fmt.Errorf("spec %d Sign: %w", i, err) + } + writeVector(&buf, i, seed, []byte(s.msg), ctx, pk.Bytes(), sk.Bytes(), sig) + } + writeFooter(&buf, "mldsa44") + return writeFormatted(path, buf.Bytes()) +} + +func genMLDSA65(path string) error { + var buf bytes.Buffer + writeHeader(&buf, "mldsa65", "ML-DSA-65 (NIST Level 3 β€” recommended)") + for i, s := range specs { + seed := bytes.Repeat([]byte{s.seedByte}, mldsa65.SeedSize) + pk, sk, err := mldsa65.NewKeyFromSeed(seed) + if err != nil { + return fmt.Errorf("spec %d NewKeyFromSeed: %w", i, err) + } + var ctx []byte + if s.ctx != "" { + ctx = []byte(s.ctx) + } + sig, err := mldsa65.Sign(sk, []byte(s.msg), ctx, false) + if err != nil { + return fmt.Errorf("spec %d Sign: %w", i, err) + } + writeVector(&buf, i, seed, []byte(s.msg), ctx, pk.Bytes(), sk.Bytes(), sig) + } + writeFooter(&buf, "mldsa65") + return writeFormatted(path, buf.Bytes()) +} + +func genMLDSA87(path string) error { + var buf bytes.Buffer + writeHeader(&buf, "mldsa87", "ML-DSA-87 (NIST Level 5)") + for i, s := range specs { + seed := bytes.Repeat([]byte{s.seedByte}, mldsa87.SeedSize) + pk, sk, err := mldsa87.NewKeyFromSeed(seed) + if err != nil { + return fmt.Errorf("spec %d NewKeyFromSeed: %w", i, err) + } + var ctx []byte + if s.ctx != "" { + ctx = []byte(s.ctx) + } + sig, err := mldsa87.Sign(sk, []byte(s.msg), ctx, false) + if err != nil { + return fmt.Errorf("spec %d Sign: %w", i, err) + } + writeVector(&buf, i, seed, []byte(s.msg), ctx, pk.Bytes(), sk.Bytes(), sig) + } + writeFooter(&buf, "mldsa87") + return writeFormatted(path, buf.Bytes()) +} + +// writeHeader emits the file preamble: copyright, // Code generated +// marker (so editor tooling flags it as machine-written), package +// statement, and the start of the per-parameter-set vectors slice. +func writeHeader(buf *bytes.Buffer, paramSet, label string) { + fmt.Fprintln(buf, "// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.") + fmt.Fprintln(buf, "// See the file LICENSE for licensing terms.") + fmt.Fprintln(buf) + fmt.Fprintln(buf, "// Code generated by pq/mldsa/kats/internal/gen. DO NOT EDIT.") + fmt.Fprintln(buf) + fmt.Fprintln(buf, "package kats") + fmt.Fprintln(buf) + fmt.Fprintf(buf, "// Vectors%s holds the synthetic Known-Answer-Test vectors for the\n", + strings.ToUpper(paramSet[len("mldsa"):])) + fmt.Fprintf(buf, "// %s parameter set. Regenerate via `make gen_kats`.\n", label) + fmt.Fprintf(buf, "var Vectors%s = []Vector{\n", strings.ToUpper(paramSet[len("mldsa"):])) +} + +// writeFooter emits the closing brace of the slice literal. +func writeFooter(buf *bytes.Buffer, _ string) { + fmt.Fprintln(buf, "}") +} + +// writeVector emits one Vector{...} struct literal. Each byte slice +// is emitted via hexBytes() for compact, diff-friendly output. +func writeVector(buf *bytes.Buffer, count int, seed, msg, ctx, pk, sk, sig []byte) { + fmt.Fprintln(buf, "\t{") + fmt.Fprintf(buf, "\t\tCount: %d,\n", count) + fmt.Fprintf(buf, "\t\tSeed: %s,\n", hexBytes(seed)) + fmt.Fprintf(buf, "\t\tMsg: %s,\n", hexBytes(msg)) + fmt.Fprintf(buf, "\t\tCtx: %s,\n", hexBytes(ctx)) + fmt.Fprintf(buf, "\t\tPublicKey: %s,\n", hexBytes(pk)) + fmt.Fprintf(buf, "\t\tPrivateKey: %s,\n", hexBytes(sk)) + fmt.Fprintf(buf, "\t\tSignature: %s,\n", hexBytes(sig)) + fmt.Fprintln(buf, "\t},") +} + +// hexBytes renders a []byte slice as a Go literal. nil is preserved +// as `nil` (not `[]byte{}`) so the test can distinguish the two. +// Non-nil slices use the `mustDecodeHex("...")` helper defined in +// vectors_helpers.go for compact source output. +func hexBytes(b []byte) string { + if b == nil { + return "nil" + } + if len(b) == 0 { + return "[]byte{}" + } + return fmt.Sprintf("mustDecodeHex(%q)", hexString(b)) +} + +func hexString(b []byte) string { + const hexdigits = "0123456789abcdef" + out := make([]byte, len(b)*2) + for i, x := range b { + out[i*2] = hexdigits[x>>4] + out[i*2+1] = hexdigits[x&0x0f] + } + return string(out) +} + +func writeFormatted(path string, src []byte) error { + formatted, err := format.Source(src) + if err != nil { + // Write the unformatted source for diagnosis, then fail. + _ = os.WriteFile(path+".unformatted", src, 0o644) + return fmt.Errorf("gofmt: %w (unformatted source written to %s.unformatted)", err, path) + } + return os.WriteFile(path, formatted, 0o644) +} + +func die(format string, args ...any) { + fmt.Fprintf(os.Stderr, "gen: "+format+"\n", args...) + os.Exit(1) +} diff --git a/pq/mldsa/kats/kat_test.go b/pq/mldsa/kats/kat_test.go new file mode 100644 index 0000000..ff75a8b --- /dev/null +++ b/pq/mldsa/kats/kat_test.go @@ -0,0 +1,211 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package kats + +import ( + "bytes" + "testing" + + "github.com/luxfi/crypto/pq/mldsa/mldsa44" + "github.com/luxfi/crypto/pq/mldsa/mldsa65" + "github.com/luxfi/crypto/pq/mldsa/mldsa87" +) + +// TestKAT_MLDSA44 walks Vectors44 and asserts byte-equality on the +// derived public key, private key, and deterministic signature for +// every record. A failure here means the synthetic vector pin is +// stale β€” either the upstream CIRCL implementation moved (in which +// case we want to know before downstream consumers do) or the +// generator was run without committing its output. +func TestKAT_MLDSA44(t *testing.T) { + if len(Vectors44) == 0 { + t.Fatal("Vectors44 is empty β€” did you forget to run `make gen_kats`?") + } + for _, v := range Vectors44 { + v := v + t.Run(vectorName("mldsa44", v.Count), func(t *testing.T) { + pk, sk, err := mldsa44.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("count %d NewKeyFromSeed: %v", v.Count, err) + } + if !bytes.Equal(pk.Bytes(), v.PublicKey) { + t.Fatalf("count %d: public key mismatch (got %d bytes, want %d)", + v.Count, len(pk.Bytes()), len(v.PublicKey)) + } + if !bytes.Equal(sk.Bytes(), v.PrivateKey) { + t.Fatalf("count %d: private key mismatch", v.Count) + } + sig, err := mldsa44.Sign(sk, v.Msg, v.Ctx, false) + if err != nil { + t.Fatalf("count %d Sign: %v", v.Count, err) + } + if !bytes.Equal(sig, v.Signature) { + t.Fatalf("count %d: signature mismatch", v.Count) + } + if !mldsa44.Verify(pk, v.Msg, v.Ctx, v.Signature) { + t.Fatalf("count %d: pinned signature does not verify", v.Count) + } + // Bad signature MUST be rejected. Flip a bit in c~ (the + // first byte of sig) which is always present. + bad := append([]byte{}, v.Signature...) + bad[0] ^= 0x01 + if mldsa44.Verify(pk, v.Msg, v.Ctx, bad) { + t.Fatalf("count %d: tampered signature accepted", v.Count) + } + }) + } +} + +// TestKAT_MLDSA65 is the Level 3 counterpart of TestKAT_MLDSA44. +func TestKAT_MLDSA65(t *testing.T) { + if len(Vectors65) == 0 { + t.Fatal("Vectors65 is empty β€” did you forget to run `make gen_kats`?") + } + for _, v := range Vectors65 { + v := v + t.Run(vectorName("mldsa65", v.Count), func(t *testing.T) { + pk, sk, err := mldsa65.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("count %d NewKeyFromSeed: %v", v.Count, err) + } + if !bytes.Equal(pk.Bytes(), v.PublicKey) { + t.Fatalf("count %d: public key mismatch", v.Count) + } + if !bytes.Equal(sk.Bytes(), v.PrivateKey) { + t.Fatalf("count %d: private key mismatch", v.Count) + } + sig, err := mldsa65.Sign(sk, v.Msg, v.Ctx, false) + if err != nil { + t.Fatalf("count %d Sign: %v", v.Count, err) + } + if !bytes.Equal(sig, v.Signature) { + t.Fatalf("count %d: signature mismatch", v.Count) + } + if !mldsa65.Verify(pk, v.Msg, v.Ctx, v.Signature) { + t.Fatalf("count %d: pinned signature does not verify", v.Count) + } + bad := append([]byte{}, v.Signature...) + bad[0] ^= 0x01 + if mldsa65.Verify(pk, v.Msg, v.Ctx, bad) { + t.Fatalf("count %d: tampered signature accepted", v.Count) + } + }) + } +} + +// TestKAT_MLDSA87 is the Level 5 counterpart. +func TestKAT_MLDSA87(t *testing.T) { + if len(Vectors87) == 0 { + t.Fatal("Vectors87 is empty β€” did you forget to run `make gen_kats`?") + } + for _, v := range Vectors87 { + v := v + t.Run(vectorName("mldsa87", v.Count), func(t *testing.T) { + pk, sk, err := mldsa87.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("count %d NewKeyFromSeed: %v", v.Count, err) + } + if !bytes.Equal(pk.Bytes(), v.PublicKey) { + t.Fatalf("count %d: public key mismatch", v.Count) + } + if !bytes.Equal(sk.Bytes(), v.PrivateKey) { + t.Fatalf("count %d: private key mismatch", v.Count) + } + sig, err := mldsa87.Sign(sk, v.Msg, v.Ctx, false) + if err != nil { + t.Fatalf("count %d Sign: %v", v.Count, err) + } + if !bytes.Equal(sig, v.Signature) { + t.Fatalf("count %d: signature mismatch", v.Count) + } + if !mldsa87.Verify(pk, v.Msg, v.Ctx, v.Signature) { + t.Fatalf("count %d: pinned signature does not verify", v.Count) + } + bad := append([]byte{}, v.Signature...) + bad[0] ^= 0x01 + if mldsa87.Verify(pk, v.Msg, v.Ctx, bad) { + t.Fatalf("count %d: tampered signature accepted", v.Count) + } + }) + } +} + +// TestKAT_RandomizedSignVerifies is the companion to the +// deterministic-sign tests above. It does NOT pin signature bytes +// (a randomized signature has fresh nonce material every call), but +// it asserts that the deterministic-keygen + randomized-sign path +// produces a signature that verifies under the pinned public key. +// +// The test covers all three parameter sets and one vector each. +func TestKAT_RandomizedSignVerifies(t *testing.T) { + if len(Vectors44) > 0 { + v := Vectors44[0] + _, sk, err := mldsa44.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("mldsa44 keygen: %v", err) + } + sig, err := mldsa44.Sign(sk, v.Msg, v.Ctx, true) + if err != nil { + t.Fatalf("mldsa44 randomized Sign: %v", err) + } + var pkBuf [mldsa44.PublicKeySize]byte + copy(pkBuf[:], v.PublicKey) + var pk mldsa44.PublicKey + pk.Unpack(&pkBuf) + if !mldsa44.Verify(&pk, v.Msg, v.Ctx, sig) { + t.Fatal("mldsa44 randomized sig fails Verify under pinned pk") + } + } + if len(Vectors65) > 0 { + v := Vectors65[0] + _, sk, err := mldsa65.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("mldsa65 keygen: %v", err) + } + sig, err := mldsa65.Sign(sk, v.Msg, v.Ctx, true) + if err != nil { + t.Fatalf("mldsa65 randomized Sign: %v", err) + } + var pkBuf [mldsa65.PublicKeySize]byte + copy(pkBuf[:], v.PublicKey) + var pk mldsa65.PublicKey + pk.Unpack(&pkBuf) + if !mldsa65.Verify(&pk, v.Msg, v.Ctx, sig) { + t.Fatal("mldsa65 randomized sig fails Verify under pinned pk") + } + } + if len(Vectors87) > 0 { + v := Vectors87[0] + _, sk, err := mldsa87.NewKeyFromSeed(v.Seed) + if err != nil { + t.Fatalf("mldsa87 keygen: %v", err) + } + sig, err := mldsa87.Sign(sk, v.Msg, v.Ctx, true) + if err != nil { + t.Fatalf("mldsa87 randomized Sign: %v", err) + } + var pkBuf [mldsa87.PublicKeySize]byte + copy(pkBuf[:], v.PublicKey) + var pk mldsa87.PublicKey + pk.Unpack(&pkBuf) + if !mldsa87.Verify(&pk, v.Msg, v.Ctx, sig) { + t.Fatal("mldsa87 randomized sig fails Verify under pinned pk") + } + } +} + +// vectorName produces a stable sub-test name for `go test -run` +// filtering. The format is "/count". +func vectorName(param string, count int) string { + return param + "/count" + fmtInt(count) +} + +func fmtInt(n int) string { + if n < 10 { + return string(rune('0' + n)) + } + // Two-digit max: our specs slice is short and the count never + // exceeds 99. If that changes, expand this helper. + return string(rune('0'+n/10)) + string(rune('0'+n%10)) +} diff --git a/pq/mldsa/kats/regen_test.go b/pq/mldsa/kats/regen_test.go new file mode 100644 index 0000000..d767596 --- /dev/null +++ b/pq/mldsa/kats/regen_test.go @@ -0,0 +1,122 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package kats + +import ( + "bytes" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" + "testing" +) + +// TestRegen_Deterministic invokes the same generator the Makefile +// target uses (`go run ./pq/mldsa/kats/internal/gen`) against a +// temporary output directory and asserts the resulting files are +// byte-identical to the checked-in vectors_mldsaXX.go files. +// +// This is the "two-pass discipline" guard. A drift here means +// either (a) someone hand-edited the generated vectors, or (b) the +// generator changed but `make gen_kats` was not re-run before +// commit. Either is a defect. +// +// The test is skipped when the test binary cannot find a `go` +// executable on PATH (e.g. in a stripped CI image); the regression +// risk in that case is bounded β€” the gen_kats Makefile target is +// expected to be re-run separately. +func TestRegen_Deterministic(t *testing.T) { + goBin, err := exec.LookPath("go") + if err != nil { + t.Skipf("go not on PATH: %v", err) + } + if os.Getenv("LUX_SKIP_REGEN") == "1" { + // Escape hatch for environments where invoking `go run` + // inside a test is undesirable (sandboxed runners that + // disallow nested compilation). + t.Skip("LUX_SKIP_REGEN=1") + } + + tmp := t.TempDir() + + // Resolve repo root from this source file's location: kats lives + // at /pq/mldsa/kats; go up three to reach . + _, thisFile, _, ok := runtime.Caller(0) + if !ok { + t.Fatal("runtime.Caller(0) failed; cannot locate source file") + } + repoRoot := filepath.Clean(filepath.Join(filepath.Dir(thisFile), "..", "..", "..")) + + cmd := exec.Command(goBin, "run", + "github.com/luxfi/crypto/pq/mldsa/kats/internal/gen", + "-out", tmp, + ) + cmd.Dir = repoRoot + // Inherit Go env including GOPROXY; explicitly disable workspace + // so the generator builds against this module's own go.mod + // (matches CI behavior). + cmd.Env = append(os.Environ(), "GOWORK=off") + out, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("go run gen: %v\n%s", err, out) + } + + for _, name := range []string{ + "vectors_mldsa44.go", + "vectors_mldsa65.go", + "vectors_mldsa87.go", + } { + freshPath := filepath.Join(tmp, name) + pinnedPath := filepath.Join(filepath.Dir(thisFile), name) + + fresh, err := os.ReadFile(freshPath) + if err != nil { + t.Fatalf("read fresh %s: %v", name, err) + } + pinned, err := os.ReadFile(pinnedPath) + if err != nil { + t.Fatalf("read pinned %s: %v", name, err) + } + if !bytes.Equal(fresh, pinned) { + // Surface the first differing line so the diagnosis is + // short. Big hex literals make a full diff useless. + line, freshLine, pinnedLine := firstDiffLine(fresh, pinned) + t.Fatalf("%s: regenerated bytes differ from pinned source\n"+ + "first diff at line %d:\n fresh: %q\n pinned: %q\n"+ + "hint: run `make gen_kats` and commit the result", + name, line, + truncate(freshLine, 120), truncate(pinnedLine, 120)) + } + } +} + +func firstDiffLine(a, b []byte) (line int, aLine, bLine string) { + la := strings.Split(string(a), "\n") + lb := strings.Split(string(b), "\n") + n := len(la) + if len(lb) < n { + n = len(lb) + } + for i := 0; i < n; i++ { + if la[i] != lb[i] { + return i + 1, la[i], lb[i] + } + } + if len(la) != len(lb) { + // One file has trailing lines. + if len(la) > n { + return n + 1, la[n], "" + } + return n + 1, "", lb[n] + } + return 0, "", "" +} + +func truncate(s string, max int) string { + if len(s) <= max { + return s + } + return s[:max] + "...(truncated)" +} diff --git a/pq/mldsa/kats/vector.go b/pq/mldsa/kats/vector.go new file mode 100644 index 0000000..2715150 --- /dev/null +++ b/pq/mldsa/kats/vector.go @@ -0,0 +1,27 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package kats + +// Vector is one Known-Answer-Test record. Every field is the +// canonical FIPS 204 wire encoding of the value (Seed = 32-byte ΞΎ; +// PublicKey, PrivateKey, Signature = mldsaXX wire bytes; Msg, Ctx +// = arbitrary byte slices). +type Vector struct { + // Count is the vector index within its parameter-set slice; + // surfaced in test failure messages so a diff is easy to pin. + Count int + // Seed is the 32-byte ΞΎ fed to NewKeyFromSeed. + Seed []byte + // Msg is the message bytes passed to Sign / Verify. + Msg []byte + // Ctx is the domain-separation context. May be empty. + Ctx []byte + // PublicKey is the expected mldsaXX.PublicKey.Bytes() output. + PublicKey []byte + // PrivateKey is the expected mldsaXX.PrivateKey.Bytes() output. + PrivateKey []byte + // Signature is the expected deterministic + // mldsaXX.Sign(sk, Msg, Ctx, false) output. + Signature []byte +} diff --git a/pq/mldsa/kats/vectors_helpers.go b/pq/mldsa/kats/vectors_helpers.go new file mode 100644 index 0000000..36bc15b --- /dev/null +++ b/pq/mldsa/kats/vectors_helpers.go @@ -0,0 +1,20 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package kats + +import ( + "encoding/hex" +) + +// mustDecodeHex is the helper the generated vectors_mldsaXX.go +// files call to inline byte literals. A malformed input is a +// compile-time defect β€” we panic so tests fail loudly at init +// rather than producing silent zero-byte slices. +func mustDecodeHex(s string) []byte { + b, err := hex.DecodeString(s) + if err != nil { + panic("kats: bad hex literal: " + err.Error()) + } + return b +} diff --git a/pq/mldsa/kats/vectors_mldsa44.go b/pq/mldsa/kats/vectors_mldsa44.go new file mode 100644 index 0000000..bcee8d7 --- /dev/null +++ b/pq/mldsa/kats/vectors_mldsa44.go @@ -0,0 +1,56 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Code generated by pq/mldsa/kats/internal/gen. DO NOT EDIT. + +package kats + +// Vectors44 holds the synthetic Known-Answer-Test vectors for the +// ML-DSA-44 (NIST Level 2) parameter set. Regenerate via `make gen_kats`. +var Vectors44 = []Vector{ + { + Count: 0, + Seed: mustDecodeHex("0000000000000000000000000000000000000000000000000000000000000000"), + Msg: []byte{}, + Ctx: nil, + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 1, + Seed: mustDecodeHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), + Msg: mustDecodeHex("46495053323034204b415420616c6c2d6f6e65732073656564"), + Ctx: mustDecodeHex("4c55582f4b41542f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 2, + Seed: mustDecodeHex("4242424242424242424242424242424242424242424242424242424242424242"), + Msg: mustDecodeHex("64657465726d696e6973746963204d4c2d445341207369676e6174757265"), + Ctx: nil, + PublicKey: mustDecodeHex("dfab4158c8952a54f8bd019ae3ccba701bd8f0baf78e308d71c2b6a7f95a70668d291af8c54de4c8707b0068be72e4da2d0e319d82fc23c1025858645449a927bf52cdf81fa06dc8c0791ba1ed14201d30670b539ddcd31d501b7b618db72039b4bf911245f76d0b41bcd4389f06a2fd6d312d644b27939034580c0ee3f1bd14528fefb59219d45fbe15371e509fd2784b4324e9a3d234fcf351254b571889713744f926df76b778cd3d6824f9442acf0c42d0c71797f2d59bf156f43348336faaca71819386d5983ff340499189dfaede03e29778908eadcc9390b85ac9a7b4900b5a7c5cd58d06423cd5cd666b77351008def98a1426b73179c50882b5318b21f9ff8235cc5a61f135a88e0a98d19e68b6405ef78a48eb50a2c3b772c03aa9c5f332efff9e93c79328ccfbf7353fba7c124023742799e4f424926d743cda109be5716951942395a51fc36b66dddd9afb45feca30adcd6809f484608db8f9b05820dec3a5fe076c8ba456c33755ea4f6cc69cb9a27d3e985ea4753815c3efc1decedaf4e488a91bb8216629d621860b75ea027d9b47843da4ee031b3a4aa3b1d1da2cc70a0d9d29eaa11e721991bed9204123464b2a823f85a01304097114ae9f66e5560db7830a6191380943d7dc4547b9980d74a9333408afff51816611ad1962641f9cb3e4cc5d5db896e11cdb15219bf88cc8dc3a97f8414c884824b2d9763930a10aeb5e4dc637a8bfce19e3a4b112a2d67d13e6e0ad1888dd89a828d3871376b740db3fef153f6656b4df6ce5602e6902382a6f5ada047a80e80077032cee6870eca2159363c8d57168a3f7766f32a5e59a6559a7609a5452194a3d292cf8c28466c6de926cc8e8bbbafde77c60be7becb75b86fe68707ef2cf4410fd725234bcf0869b35bf10ce1c9f5ea36461d1032181fd8871807179ab2e9bd7e24b53693dffb8753eca17ced2a675b174772a74a7fe5dc80ad10e66c98b9d7031334ce3168c96c3bf56c63b20dc4478a07daf394a5b68a929fdeb1e91b127464a765bfc0e9334e72be72d4c7236fb42b84822bc45249a5845494a4b5be3927561762ef9e3a39aa31c2765a4d217f9649017de1ab834bc31ad58dff16877c607283983fb29692e457ce5711827073578555b3612b46ddc2e92a308029540d354513231fb4f94a3c4f1e42956bd91e9d4c4d75725ba0542dc678cedb6de812c713015d67abd8a03f0bc03d894efdce2f326634d3e2c422b92890ca3eb7228920e2a485deadc60b92d9fbd5a82a8f1f012ef852049aa40413b4fa5d0e4ca2464978fbe56c5211c4e59998c048d689121cba0c011c783462452b1a183448d18a13c013184080e766afba778de67c12da98a6072a524bc2242d93bc6d9c0842c0bdf992a06c2e202588beed1adc7f03b21d50f7745869adfdfc9b33003fccf54180f6248f8726e4496d13e42e4dfb61b511d2cee098d783a85482bd600ce7204f052b5bdf786933c7fb8448b5809d1884335405c2c1b70053985aae87b655a01a25caf98c64620fdf2aca55c9c5d064674fa4f281a17172e1bbb6f804a5fa7850f8a457a8eebceedd9ec2c6d4a056f7a18b6e14b46dc1dd2bccfca8c755c635c8c59a95e52dbd53ad4483ad27bdb0bdd6198d076cc69e14375181c33d5ac7d8debb5f6de8901a8976fe3b919d0ac8564d213e71650cbc05ec8ab39a21039d2f33c3113ccff090e45031bc426915a43d4860d5623d685e6940340260febd35c06427d806cfa93b6e2df43ba7d1ffe60f3d63b5ed4e30386def7e7b94ee13ab21ac6eace87f7b286913d0e0e44b73827519cad3c5dd2d459e3a2cf952bedf59d8256f296"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 3, + Seed: mustDecodeHex("a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5"), + Msg: mustDecodeHex("636f6e746578742d626f756e64207369676e6174757265"), + Ctx: mustDecodeHex("4c55582f4b41542f6374782f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("908102ef197addb6c85fec17be01c0593ed9e8af87f5bd7bfcbb6a7b4083bb69a20254f8976c9ea860e14e2b2a2eb38e0590ca5ae2392d9367383b1cb4e7b4c5f3b5bd4a167cedc185755b55ba6d2eaa47b4f77827fe09259f9ab6421dac0beaf69638cc7586bb86fc5521b61802bf98cdc1645f50a01a39f3494dcefd0e3c0a18c0095232468bc0505a20908c365203261202018590c64581a824e122522303126406461a836c024241e4248882062c024632e0020c142170d080654ac691c1a821d8946003220a0c112a21938d00034a143970e0c20108c14cd9306d82c86508971160820953968193068d04306d4ba08981b8018b06201343524b428448a251c81690993401e0082a44b2519482002026800a360ccba24024440860a46d0c430583b040cba221c3a084c4901149b6250335450c91709a26821bc844538009cc226e21036899428a09282ee22425514445124250999411981402da2064c134664b06019248254190891b1280091169a0482d40248803a6004b3431cb0020e4460d03278099c8605c086512a1701ab204033841a1c829dac88940a46c229551591001a340829c066c1a436c891088c324320b1930a0c225023450db220ca0c645e312400b878dc23082c1c48823c901c8062d1c1741d3106d93146248b880c8c801ca884421a66463a82090a0051006014b082e248851410060d2166c52305050b669c3284581280aa3102d213868e0082c61c8212239490307019b189290a86c50b22c10b87051441104a170590006d9464059226640b8880a972948320e54b68544984594322c4a168e18380c04158d424684dc88688a968889c88450c28419c965228184db48059c361102917018a01112368d49342ca232698906704b3809504028ca1686e20832498209d3a01122c98dd0422d08430e0482101a24848b2269a402304b260890b64998b66890340122a430cc36910a310e0a36064aa44503b90902a441d32860a200311b2606d024458a94445110612322028386291b98510b408209308d20284a93022e90404d01024920452552326414888de32052910466c0c6714b9430dc28601923520c359221224a60c28912232c13c4508c382e20406ad3286c18484c5b8050884470c198110111915c305092080888a08144322288446e01a3089c94841b9209e0822c423490a0244e1c418d42244998460c9cb0504b328e92266c4b06201b912ce28824d9389111b42922140a0ca7259b08060b1d145191426554ba4e091389fa57261bd6f1831b995a69cb824ea2f0b627ef4b3a517a34e7438e1899410e569aa62980200d9be57d8d59c7e99f5365de3e57e6a6630e6bc1527833309ab08ca06566b1dc2e7f035ba6aa9c0b35a43aaf5d2b4b8ea37800e39b95e6d43ee5f67a20aaf676a33c342a4413f5d0150fdd68be3adf1fd9c36a35625b7a641f5c8255473b17ffa1d8d1ca4aa82264dcfb3c82fd14c02d0b1bff1417a26cd101e8b8c66cc5f801ae331d9c1de57ed7738aeb5fdb7034a9226b5c87d22c8d0abaf80c62f82231258dcfd322937fe45ae3c425a1e4a432a7c0e23f770cefdd1b76dad486538425cda9810643efe749147d61e2dd9c1356ad5bcee6e65f12d9baa309a75bf3dcac0a5dc86e3838769887812cf0d2c9819bea01022836ce3d0742d35dce9582ffa414ed68ad82fdd63da67fbba197ac0954b52ae8e9819ac4ce06deec4752e3817801b8c6f62337a239a668ab540f8844ff4cd8608e5dda33805b3d66252611c9b0c54a2876f0bf63f9946f1c0672e905e014b3c72982b4ab18ed3303ebf3879064288c90c4d51e65eccd6a0ce21e0ead183aed3cb2b7806f42128fabcd2a5212a36729c4025de1e39fd66aa12a05fd3a23dfa9661b6f1f270aab3535cd5fef805ee96b4da990e1b32d5e5b086819ce39479c0a8077d11e52503562d6d60472ed77d01ade8f787d7d9f48db0fc167c3830d5b380bf4e5c3addb36025c6d9eba54009145afe80b103d02a8ae00273e72e137a88ab88e5542f80a597803dbd378a897373f8d5b5d450b242b6c75f12c2474b3438b5f236de8d855a83c6f6990aecfd9d63422125858873ff4235ec8d001fb23231d234656c09a9522dac194890ea21b66bf36d05e4995f9f77b033f323050d69c8dde82d4a15cbff4c8e7fe5df007096f391ba70c4b672f648fd67f064ec42f004ef1effba81f21bbdd61c8526753ef0ba432989600b00fb3eec340f51bebca7a47da02615a62516ebec495b76844eb7bde51327a1d68991fd6ece3d74fb378f7972adfbfd50a2a795484762ad6fc40acbcc10368cb744f8e759d6d15610d1ebe14c82695ccde93f0eb579d21bfd47e3f39b1972900258d6f4a8b5bf6944267380122200e09131c2a5fe459abd3f0dbe9664962b31b768bb595cadc7dc5e7d7c0b61ab737703a17da5c0761975c5d88c2db04feb3f7a02a91e9025a83981210498a7b2b83f4d663002e28c50f044c80dee026f7ac1112311fa7df1013cdc2666f0832c43855ae792c7d60c647aa6b763888e0db93a3134ae574976cf4324556a8be833a3756f2736b1da9755f830a37eb47bf9777f687b3ec45106f117c8d3724e4022eae3d78e8dbe2c2b093e26080ebbd5f012cfac67119be3a35c16f271e96b6c236725de44f71799a8925dc1a00d7f27e4c96008b51dffda2cc4782eca1b6c92c886d0982990f989c5713d3b7d2df0bc31473ff777b772450d19363bd3dfa0213daaff887b7f3bf36a08a646ddebf2eeffb25f0ac1a2ebccfbfde997548d8b41dd14572fea285bca09588f0b297abb3fa41c27334d70409e61b701b5e7090ad3027f0d6b73d09763aa6afd28fc550683e2e82b1693afc4934b2d67564bb0d3c01fb95dc38c4f9d5591b2e533f90d07ceb42310b521dc39193e44f358645552c6a1c7f481704ff63279ab7836fdce129816b0c56b7be00a60b28a5de30fb2040e88238f66901b6ac983b8e285989e4e23f8832076abf1043b6ca51d7ce68b975c39fa96637dd9c81d4385238d1cd103bc6912590edd4e4e702b7e001fb01487868ac93db930880c08e7344cea550c84d377ee31282a6d943d7d5cb989a2c4538a8a3b3c7ec3475e3dfc9facf03d4e2b18abc529601a8193b6001c6f94240f1d0b6a3ea5e35adeb05a899a240a5d4a70ee7606fe1600dc39aa6648c53f488b5fea46c8ee75e65d82672d062070f0fee97398f062fa1b136ba74a3301b1347fc18e85b407c75a862cd13df7fb7d6a695195e81f00ed1e4c6dbe6fba64859e0c89b645dc473b02634c50c27e102268aed1f49f99a875a45b490f2f06a3276ac78825775ae59896c0ce86c8661caeca23a9e8e2c70af0131b87fda2772d4afe81499bf84eed0ac5802a734532e99e5bf49f1cb33b11bd458e2a8e4f357ec949706c4b58b5fa92488ae5d089a80f1b920045431660d03684065a98d3253ba1c6a15665afa4d438263628f36aa54b9c92389acf16197ae5b891c0754d21d9ea1190353fac15db5c61f1b1f8b6260b6741dd070719f5f34350257361991596aa76e78797cea660fceafbdf4a65c3d9fcbc3ec5a55e9d3f0ebd0cf028c5a1d65b4"), + Signature: mustDecodeHex("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"), + }, + { + Count: 4, + Seed: mustDecodeHex("5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"), + Msg: mustDecodeHex("6c6f6e67206d6573736167652f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f"), + Ctx: mustDecodeHex("4c55582f4b41542f6c6f6e676d73672f7631"), + PublicKey: mustDecodeHex("ad5302fcb6d19c59fd6c3d78828cac1df195dc2ceba8f3932c1b72d0420d5053c463bb58a7cf1c578a025074d7d9b8b5021e764ea268a5dce3b4520103ed6ddba0b9584b97563442d5e0079e3c2e966c7521972ecd5eafa540c7b4975713f57d6937b61f16fb4415afca0efbaff7cdd66237a798ab5e968dba01cdf1c4c8b68fde62004e7df465262db68d3b2c8c46b9d20b2c4cd017879d13ff8253eabeadd8cfb745d6dfd857399288f89800da9f4b95fb95735ec44b65909d9ab8be6195d53d33d8a7cee4bfd5529f0009d9e219b34c342ceb6fce5b4453b39eae0b44470fc30071d3616b8c812319e6be6965cb3a67b14911a4f9d661ffcd33abcaa440b347912a3581002ee73c90ace7c97a08486d77e8e249de96fd9b8b069f7c945562e9f28f7f168cc7d0182305d60192d1cb7db8792df01230bd32623f78c82528230b25c307b358a982c28a3596b36f137d035df346dbfc73de3cd0684e905922aca7af6a3bb3b6dc3a5e93cce2cd77f4ecee1c96ac508a23d497bfad7f9e77bda748e5ddfd63f6f87cb0c8ecebccc4d77095bf3552af08b0d0fc9e0dbe7042a8d0b520e9320d62a27adfcedc66e9f954d064d580bd6cd26423c42a73db3cf8a191bec5b7c26b80645fcc35ee42e2d3bcc6b5d3134f13968cc56cf29cc244e8107340e763411b3b8ff09dfc2db691dc61a724dc7ea1d234a020b23340d6d0140e98dce4d2f8f6e71de14351400a908666b8807ae4fcfdf4dc2b2fbfd076f0ec91c92c2a6be2857c0e2c831dc9e9113aac953f17c09bae298732b02ff30431b04df2c52847ac3ec8b4d93c21318899f3ca895dc5a883f88b7f0f58cffafadd8703bf8baf2477d11d37519872bf4472fd59c641d17b54d762cf40e1cbc2b728790f61bdada63f53bf7f39d1b7273fe30ee85f38f6d6cdb0aadff520cd592147c93f0a62ae961fe69b65eceac7bd62ca8508826672792a10ae624f48f0fbda344b34015877fe4abe4af148e40ada1c334c025d19ef3277d2ccb54fbe7de2a038794ecd796ec5de0a45686a5a63c9ef54d0cbfc29a8ec463857e8f47b8abc2990d16f3ed4a3e4703694ae81fd674fb916e05d708ddc7a4f0906f1151ce70105f473aeac5437551e1dd705b8a0dfec7d45c91ab12925907e68ddcd74713993cc8fc1d87b4a15d56a49fbaa453c65b2c313ea8c9dc72f3e71e1195b474fbaa11aa7c63918bddcf67d63650d7a95601d0b91732519f507046be4c03d51edfb3327699593f4de65e9b4fed75313184ff72417092ac47e93e6660e6013f0c6a78076193d757d9e6cdea877372f8e254330fd13ca3f8d43f247a27cf63e1bc03fa2d757221d89edb563532b4aa0b43d5646787eb1457b3f47082af42d55bded26a122a726208b5d1ce15c834af6e6e75a4c62df4b083bfb1eae314f5d528962e1e0db67e7df89d2db0dc254b685e3659cbc4c59b8d193566242ef0883f84cd973436e973d507f683bc85493040f14d74b86442ec47483452934ad08bee5aad9d6ec1d390c57987f3a8a5775cf655a01df6e3394339b76504844745b6814f0d4043eb55b11df12381d68861f101c7a0c695d4643ba5ca64b9b87c5b9006b557acffdf3fa43a95b580078502b0422815ff0d39f0b1ce6779713b861c2cc4789c9b99781fe55e2009b6d79c2bbfb10b142acf586ecb031008d06363f200a205f26cde7ded87a2df88e6be5800e587fca5f08ff5ef5028285ccac4684e1f1e5774f2d27df31b2381782abf28bc071d115d1d028bb16e53dbfdb9afe55ef8a7e0b4ca7ef2601175c715bddef1ba31f933ce3cdbff71c4f29c2eb71936134beacb0b0007b7b7200f6ad"), + PrivateKey: mustDecodeHex("ad5302fcb6d19c59fd6c3d78828cac1df195dc2ceba8f3932c1b72d0420d5053b1bd5243891446272589fdf811874efc09b297bf131f8110a3bf69e2692bd0dcf30f4bf7aa2ba9f7a68d73c90f0ebf2b4b95d9cc96fc6729e400143d02d273df5e234d796dc16fe2c443bbe8b0d7a6901eb500f6f9b5def2f4ef954b925c705461945164082284946d5cb80c81466988b088cab22420034d43224810350e64846cca820c88402459160c8424611aa770544252191065200480d31621481604013570221970d9c2091c0724000449d91268e344694a262ca2c8894c04244ba6085010442207502021880c4989844691d4082c921200cca24909c8006040449436714a9671db3460e294682397892325611ba191620686c3123001296c63c46c9ca22c08430c0890440a104e5c186a1815305a029114090ee0306e94c82519360618448651b490123588a1883119c30c9bc6498c3045a4244e0232621834048c38720ba72040224124928c60042112260dc0026644446e831850c1222194c084da4405a1060619138ddcb44900455040945023a87123b36d64863020926592380811864484162202a220dc066d943065d112098844728aa86519a59180a60da044649b2051e3020100229121b140d1b04444062ed840016420261c3526e0028a1b142c00b651d3424e148368a1868c9b8265d8362412c66081442a603891a0346991b8200bc48da3162611452a93386852482411112614a40c24150c544646e2820d190561139311910270533864c2448ee148105302641bc7800a1684da3472023351c0b84509300dd4c811601811e2242a21b96d1b244a02c50cd044815b36250380601b344d21a74491a491e044888a0801581066a016621844864084244b40695408205a4282cb0024cbb025c4064084b060832264c9a844d2026c09038aa4a430e3920000a63109286c8b3272131481482031c2961098000a13a165119269d1a00de1288a1297318216110c256504c34593149112b54d24387000126ac9360188b208092566ccc8695a405123092450827111097209c56491b46c0a376e010742cb227022a2449c862410454c50986c8a460603212993982500c9285094410895041b806823140414016c63a6281421459b820923b770220840891669122446da0284c18880013785233088d496484210869304860ac888dba20993003052a6290cc5891a2680a0320609016943008d8a80092186815bc46dcbb04cc824659b4e492f2cf91d24041d9e00661fb3b6eb291247b38384d8fbb22ab3c4e601092fab9dbf20d5b370164ff817ab0b4a4092c2d7a224e2d49c7a4db69e8be5ecf15b6a705a18674b514428dff37240bb8ba766a2bff8f8af1e635140d83e0a0ce15a2361e9d3f195841c4d7b074388862774c9540bf6b464ecf8bbcd79ed6c5c77c0e7be590800f386869e3bd125ecc258954a90a770a550148ad78f777b9caf1462fe4fca461eeb89da3839e41d90c825492c28402a6256a53af2bbd62d3591ad101ce69fc2732bc57153011340d6d58473a8ed0694d8d78c6db02e44e9154d491f0c5633a99bd1f4a126199e091792e4f5d1794e1c1694eb98c6481c63fbbcd08a5503c234f16291fa71fff2bb169d9e390f8a975084b85ebc502ef05b1ec71f100b2edf790e19c985ded0e9ab00b95c20d502ddc5655445bed02111af7be2815e04490fb583cf32cc8cafd0af5e87a904daf333c3f2e13f3be9be461d8261fb955388b55f3e46c36cd2bc201dc110f0fc13da1ece1387b1cc0ea8628735bedb7cfe6f290220bb84e1347adb6f87d3f6628a10276beba37e2d71c796e1caa84dc56fbedd47dd2771a65bef460c74abb1411f915ea218cf5c63f0f14ee386ad5f415172c7c9bd7f609a56427c029039b787d59b076443b74352325b82b949989951320e15c0af56477cc4a1986088c2969b3bbdbf2817e39373632430a25f98ef2c63782a115344755e4b7e887ca72929b9098b13277e8cbf4508fce4a04c776ff9f1716212c4b25118ec5a255fb71326c8b22693f01b924b7d7e0fee369a1e240c673699945650ef7fdb38126b5b824a626e0940c2ab1836d7edae3b59c73ddbab3329dff2867c3dc57d759b777b47a9d486137af089f3ba9e048feda1eae5e288973f6138dadddab932dd663771c2c67b5e23a295a5e16ac2ffb38a2b588691f5871226b0e6945c05625e1b034ecf0aea315ae61118bccfb7df84c079617af74949ed18478da3c46ff8ae3828ec1a113d1c25514038d1fafa447ad0b8b6375e3bf151c60467ce633454040fb649df4036417f0da40426832edfeaa364263412d6a2eb86813605c3bf2a49a218af639cadafe624ac2830084277a30be68db28c109d5f6640e56f9d857000d95e7e1e88411a9accdb539771f29d495f57b7eb8a6baba22a68105061ebc7a5fbab594cf77211428a5538515f1673f0d6d68f1aae90997dc6ba8d854f42f62ab5c0007019322255ea2a8e6b8ca203f5fc3b8e1b44d2b64d847f2a7bea621439402a262efe07c76fa1e56e3ba2fccf26e49d0dbab78a92ae512bc24746d13da79f31d464b03475541257068bd18180eae170f3ccbc1616201a1fffde8f5b901a8168f9e0707dc4c535b06c6ad45a5571e7141b8e722f07ccf3e2ded890065a515e7c3a4385dc7d936faf1c91d562bebd8fcaa985c60c9571af9e19c0dc745775c824c3b065b3b4328fe54f60485a2aa1b8c23bb2fe0dba4b4c9b36b20329c90ecda52dc26f9b547501beee435becbe493424fc3d1d5cf55f9bc45f4aa3486642560bfd3a9de6210f2d8eba5532f1b1ab3eb6f2bd40ba9055c607db3ad998e2842b809469a3e413a1025f5065767fece8333f70d71d50de5e1a51e6bb5676b8d98e4a964c5259107034b40308f605f5c7c51f738f2db99f5a6d43b8d69fbd3066fbbe7ff900bdb356678675ded4e577ebb08dbee69672a1112ab83301758e2694ac742c4748b7bbf912f870485b57675a393ec492c2be585a580588d8d130c4a5ad4007dade49aca56e8a7c1563c2b459621a626591144123f07fdf6033a253987cb50bad906dd0dffe8e6874859cc34122f3624aa5dcd9b39492af5f0a316cbe9443cafaf1f45e8c860ce2d3ea0655908c70b3f236bddc77a72f9dc1b46c9dab18ccb84339fe1d81ff0ee9467e1558e81e68d7dbdd4cbbb5c1f55da218de98c65d33c3ee2a7c31b42e4d491e05040884a1ea624aee88c1d1d8b735778145e352a122738ca71e293a014f9b0f37da2f7ed4625fdb5c85f08b25662ea40a55c326ac86d42ee0112b6c6139b1af09f18a5886ba585e13edb5789f31d43f7416d644ea1e8a945a3fc39707277ca0f1e5942fc7bd30f4f15c154579eaaeaa37c131aff4c27f71c8f32d83061372783d9708c78bafe099bfdab205d37c098b0214464fb2894e3c1b7e6b83031f4a6d86ce37d9cf3ce6ec6cd062a6b260e03db3f99c8a6f40d6dd4fc87de8f7522169de4d6affa5256e9d7e7147195aedd58f46b8062f8999c13f7b08744dcfcc94b31e1bb2d513759d6bae0e2cdba27e95c91ea41dd31d3d3ae3812c04eea0bf07eeed57a3be7e7270a239"), + Signature: mustDecodeHex("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"), + }, +} diff --git a/pq/mldsa/kats/vectors_mldsa65.go b/pq/mldsa/kats/vectors_mldsa65.go new file mode 100644 index 0000000..1a50509 --- /dev/null +++ b/pq/mldsa/kats/vectors_mldsa65.go @@ -0,0 +1,56 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Code generated by pq/mldsa/kats/internal/gen. DO NOT EDIT. + +package kats + +// Vectors65 holds the synthetic Known-Answer-Test vectors for the +// ML-DSA-65 (NIST Level 3 β€” recommended) parameter set. Regenerate via `make gen_kats`. +var Vectors65 = []Vector{ + { + Count: 0, + Seed: mustDecodeHex("0000000000000000000000000000000000000000000000000000000000000000"), + Msg: []byte{}, + Ctx: nil, + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 1, + Seed: mustDecodeHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), + Msg: mustDecodeHex("46495053323034204b415420616c6c2d6f6e65732073656564"), + Ctx: mustDecodeHex("4c55582f4b41542f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 2, + Seed: mustDecodeHex("4242424242424242424242424242424242424242424242424242424242424242"), + Msg: mustDecodeHex("64657465726d696e6973746963204d4c2d445341207369676e6174757265"), + Ctx: nil, + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("f81b7313681284271bb1a19ef55dc529d448525cb9ca79a24ac72de99bfd13886d3207be2a9a6a59a991996c6bd31ed80a6382211185370b72a12ea2f79bbc20e4920616d471f1c10d533ff8d4f62302c7520c27ee46225816c829340e62e3c88f8087854c59180ff90c0d34e71c8d6028db01487d44d202a83e356c7c5a22b05e9851c1c5f2b95bb7195823d8fd192b2e03f1a77d1359b3f6847e7e38f5ae0913f9ab285268a94ab98ae4771b24a647f6a9b1b5915b32668d27dae195892db160a8602345ef8b16f184c26cd8294801ecfa297f033a05c93474cf3c3b085c03518c09b85bc2c103a57736b594a139175eb5c0c8e40d29ece78ec0931920c017c7898d99630ec9ddc4b848887d102354ced18f87e014962d3b66b9f46a1580ce4d8d7b1ad4a9d47fa98e927a5dcabb0083c05a8049dc90d948619648eb21707c49e0381cc937955b0bb337d9b04261aad9b9334c986927a2d29c6ace4ed153bbc3dbd859a3cfa2b243d638f7810b5ddda447d38b4b5f5ac70551073ca57d9807450409fb9affbbc21c0d95eceb5a6c8e68bdc7c2529bc67366340bb3f43816e833938ae951fbee6636cbb37a72312d1026ffd3656be316a851f637f0a08ab291f57581f2a2ed3a7e96abfea0dc0ac0b681ba2e3962a7e69bb4f3dd9c2ef29acb021a361dc5040738155b92245d0bd04f5ecc7840dd9d020ccf1516a40367d664037d1de210649cb9f2c853d71d36573f241cb87158bd32a52ab488757fa8bba98c71a8051cb18e8d8ff1a34ce135a10f295e5589d9c8e091b44dad5eda31daa9ac2e55f8442303527180cc97e3d3e87778b3fc90918f59a32b3e53b7b51048886a5a22058306864c4d3fe957ed80afc21276b0aeb66e3280b382769a869e64435495d5e5a42e9fbf552fd12967e1231a296f1b80ff25df229e5dfbce6085cfed1e188032f6539ecc5ac0ec4f8dbe3467e96a8af94cee0e46835fde3bd0c3e618faa381dc8c93d5a6ee73626caeb8984fc2ab22dfa98b0c8000f35d2765b3efddc210427cb73062259f9991e3658ebf7316db71cc09f207e5fe64d2e6c2b43a6dad0d7099dcd06316cb880876252c21ff1afc247be04f0c4b033b65b78c49eb166ec8b322ea4a2ee0b312e03414d7503e26ce6e656ea5ecc2903386fdb1977e1fe06db593fdcda5a250ba6eeb2330685df5193f972fafb35ac7114c6c29d48947f2403e45185145d0db6b80cd14e6732f0eeef84c4f350d82756439bdb29043bd82df88f2f44cf73f58ca10cad7d82ec05e749f6482a3a8428b242ca16f59b809175a67c0682f9f0973bc0775872b9d04b6cfebac1a3bb604d43ee701a533c9e44a3010a91dfd4b89a32c15571f578a1180b2aec508887d572c20afbdb969787497f697ffef140c09b957425d19e5eb0aa0ef9788cb4c92105fce469ef7d1e7affad8e8a753032e3adce37850097d1d777a0c8b13652d3d5efcdac52446d2f8a7da83e3596cc1803452485a97076daf2c7ee1ba43b14f55353a93d29d8bcb15f8e2b59f0b62df2d18cf3bfdd3d6dfc71c49938dda9713f6792cc8cce3a820fafa6b768f5448685631639e6222578d4d54edf68fba025d698ec9586783e80e171f48f19544033093e58d7da3f49f30af5140137033bfda734958be6ee8803cfb6efe058a3cbe348930054b283cbded441726f4bbfb6dd5887100bfbc5d2093bf377f562de5fccf00a71c11ce56a173163a6e8d78e66fad4d1b12b5c53481f6ee42c9e9be1a1ac466114f20cf8aa62ad4e9cc44fbdfd14f8fbe7c2a98a2f4a73637fdf76cd9a6dc61faf78f61e45de654c3ea01a2f7532291951b67f791ca1b1a9a68998a14eb45cadd91cbd342cb431e3bab37adb3076ae04c78f8034347bc0651edff52b9bd190fa2cedb5f0757ba7700e8d6af3aa7c7c1154df4d4db8807317163e4a434de515d42b3c794c3f9347c3ee5351ad7e6c7f3032518c0e733575d48f24b7873a42dfad81f595b900a7ee7f21577b4b14006d83ace3c570f958fa9f5f7970839751ce71a4b69339eae06cfc9124913e666da5e9e15a997038d789cc65ec19c495084f7872f1a2056783ec40b1ae3dba42637e75c92d3dfeacc8160cfb9caa01d74bf01e98596d7e8602dd24f2ced0448d21744c107d86270c0560cfd065f72d6b1384f79007aa9d7bd137df84be9a8540191abb3ce622551441908cbb750035e45b1675352880347d4833fb292a034aafcbfd36d72c2c7646f48f9768cb90fb7727b92d3883c6727246a64a313aa8aab6a7d05cf42a22fa697be0d2dba2e072cd6e7974c35afd77f6e2608f5d0c06eb7b6da34971600c08b33cb406fdbefa59b885e3ab4ce3db262c4eb6041fc846faa12874bd31105f3da5e7b82d6af995cb3e829b0aaaf673878fc38810c9947fcd088d4ceecd783d3dab13b34b188fcec45aad879dced7f53d95cca02e863260b1b0130c33074fc47374639d5b5a9e8d1b64c89017bcbf3c530f6adab136e8628118b6afb06c96a17a40e2011a93fbd67240db90723f592c7bbd1d17513db778c8a2a71bed957ca34093b8a4c70e685c49d750485f24f7fde842159c54d7ba2ede8413d6e1e3c5b16caf04c0c37345c5e14d5953cd9e88ada5c958a3bf675aee1fea944d8ef9b3437fe7fbb2b540d372d54e07bde74c994a17507c91938292631b8e84ee40e6c02c772874ab2bef2391d55b4ae02829d013cb2e39de9559e2646d26c95173ee95f61022a4c12704ddf60160f83113e82c37eefb752af6ed22056acd098aa4226eb6af9c20483a5e6ddbfb56fbdfe1e71638d2f286cff11d3d4ec5afee067d0209ca467bb69211d279b34ce5fad24bbfb64c97528a4c9625e53d0a47edd88a705c102f89ab2552c7616062467367fbe6252f556a8b7d110f77769f88169228ea33d661315a2ee2437c52898f5a35e8996334ee93430e50733cbb5ccd8c9cb970c75174c3a4dfffc371d6c2631b8a0e27c53ced8dfae69dfa6669ecf93037f9631c34d5db3a18dc728f93b2cb0d33f96f42650ec79a2354b41e95fccffd076a8d590f23e67ad3b7ce9781f0852768b008f10d7b4ba20666e42d309bf31c3ca0c2af56da6fc1b36d2b57a74d3cd04a1423165bcf9b16e4ff3fdf230a1d63785876d950602366840e1bbd9574dfb47a01717e7a21b63ef8bdb487231407752d495e2b381bbdd66d3d1560eb7512e945cc6e2007c8ad9df0b68000abf7784510e8c9369ec4bf543c8ab34c07eea8e3f53669222b8df712cc6fd10e09535672bb79bbe180a34535f3a3ad836d04981b99b08f5a19b0982b7180b897a00c9bc39ac7c21adfcaf08c4cbdbaa9755549a5899c01d217534841fc42d8d19045106f12967f2c5a7407d34a6533c78b316f3bbd1e95f34e3e6dddf0488e48f33248b7427a8f6bfc7beee8d1503440dd65589a8cd4782653a3975402abebd934297647aa56d350bc5dfd3f0466e1ee0409b66a65acb3973aae930953481f08deaf4fdfacdb4a14854ab5bf51c4634598147dc526003059dc587f987ae6fed5b570e066cd0eedc85f689c6c01218092f47a1c74ef16587b1ed2e27bde3cff2ad231d5a1b36263de9f8baaf2d839e8a5eb48bc677429fcc009d94aa1745bd307f22c2a224941834c08b92207019db652b352015a98961338bdb63b2f1057173da54c8bff1243d3622612b5f1869a370f53fbd20e8a33adccde07bacb02ee196cba930a8935ac34978626bf569470f8e653244706a9fce6b6f5d0944f23a8ddecb9251dba7ce10d3699250cba629919763c8fa607b32a4a86fc652ce890185a5d900cedf729e079ed7e3ede4d2f060b7ab4fa6ef629fa4eb7162ac9258f307a111c9dbe9a8f9948447b32b2502de71635697ecbcb89554cfde2d0daa3c8a5b2478797a0673bf592ae9e098e5c21c963c6cbb17efeba7c5ee03fbf049452e0a51c85ebc96b558b85f6d5ed9c8d22f61bce4dc65953de1cea617ef3de9a2ebf83f17524112ce3008bc29ddfc2fefdbc8461e534febd50b2cce7383dee1fdf55fcda6ae17614ece29efa1df21c259feb1360993d82234ce23cbc8ad2211e43e2b115f9a9a183375afda9dc39a7c88eec92303c13a4de7eacb7611aac7eb3d718887a1e89588da37a74446bcef44e0df8d58cb940e975f99cb7933762729e61bb49ae906f57c565751d1f9cdf82be133e87aac2b89b6eb076de4e3fe9ee5ddbd198bff924a11819f385ddbae21f1b75b04ff473dd43077bed4e2928170b3ac33f0b4f0875aef398886dc1457ff20b0aeed08fbf4da13e36ac084afcebf5f729a019bf04b2d4d81c8c20ae56734bf06f6d7888ab41cca4e16148be6c700b24e65c85a05a301880237bd0ecc671e573fcf972674bb671b9520158aa3ff0cd2ac61e1d213d1b7129837127e834ce5ae64ab01dfc7788d5c485738d87644de3e0609726841dda951754bea4d64e8d3e69afdca99960a223df51780ded5096d8e4f1cde52b4826cf4fe5c35c4891ccf66cb1da91bc3cbae09cda9d2569993d2a385a7ef8a67fc1f831a7905b5b600d8a1f8067e07141aa1da480409038abb3c90ef45d00220284a7b98cd3438436f8a98b8c5d1dafc090f638894a6d06dcbe510b6d9ec1b20b4d1000000000000000000000000000000000000000712191c2024"), + }, + { + Count: 3, + Seed: mustDecodeHex("a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5"), + Msg: mustDecodeHex("636f6e746578742d626f756e64207369676e6174757265"), + Ctx: mustDecodeHex("4c55582f4b41542f6374782f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 4, + Seed: mustDecodeHex("5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"), + Msg: mustDecodeHex("6c6f6e67206d6573736167652f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f"), + Ctx: mustDecodeHex("4c55582f4b41542f6c6f6e676d73672f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, +} diff --git a/pq/mldsa/kats/vectors_mldsa87.go b/pq/mldsa/kats/vectors_mldsa87.go new file mode 100644 index 0000000..d10b8ec --- /dev/null +++ b/pq/mldsa/kats/vectors_mldsa87.go @@ -0,0 +1,56 @@ +// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +// Code generated by pq/mldsa/kats/internal/gen. DO NOT EDIT. + +package kats + +// Vectors87 holds the synthetic Known-Answer-Test vectors for the +// ML-DSA-87 (NIST Level 5) parameter set. Regenerate via `make gen_kats`. +var Vectors87 = []Vector{ + { + Count: 0, + Seed: mustDecodeHex("0000000000000000000000000000000000000000000000000000000000000000"), + Msg: []byte{}, + Ctx: nil, + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 1, + Seed: mustDecodeHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), + Msg: mustDecodeHex("46495053323034204b415420616c6c2d6f6e65732073656564"), + Ctx: mustDecodeHex("4c55582f4b41542f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 2, + Seed: mustDecodeHex("4242424242424242424242424242424242424242424242424242424242424242"), + Msg: mustDecodeHex("64657465726d696e6973746963204d4c2d445341207369676e6174757265"), + Ctx: nil, + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 3, + Seed: mustDecodeHex("a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5"), + Msg: mustDecodeHex("636f6e746578742d626f756e64207369676e6174757265"), + Ctx: mustDecodeHex("4c55582f4b41542f6374782f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, + { + Count: 4, + Seed: mustDecodeHex("5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"), + Msg: mustDecodeHex("6c6f6e67206d6573736167652f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f"), + Ctx: mustDecodeHex("4c55582f4b41542f6c6f6e676d73672f7631"), + PublicKey: mustDecodeHex("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"), + PrivateKey: mustDecodeHex("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"), + Signature: mustDecodeHex("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"), + }, +}