diff --git a/mldsa/compress.go b/mldsa/compress.go new file mode 100644 index 0000000..343f830 --- /dev/null +++ b/mldsa/compress.go @@ -0,0 +1,97 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import ( + "crypto/subtle" +) + +// power2Round decomposes r into (r1, r0) such that r == r1 * 2^13 + r0 mod q, See FIPS 204, Algorithm 35, Power2Round() +// +// Note: that this code is more complex than the FIPS 204 spec since it keeps +// r0 as a positive number +// +// r mod +- 2^13 is defined as having a range of -4095..4096 +// +// i.e for r = 0..4096 r1 = 0 and r0 = 0..4096 +// at r = 4097..8191 r1 = 1 and r0 = -4095..-1 +// (but since r0 is kept positive it effectively adds q and then reduces by q if needed) +// Similarly for the range r = 8192..8192+4096 r1=1 and r0=0..4096 +// & 12289..16383 r1=2 and r0=-4095..-1 +func power2Round(r fieldElement) (r1, r0 fieldElement) { + r1 = r >> d + r0 = r - r1<> 1 + ) + + r0Adjusted := fieldSub(r0, dv) + r1Adjusted := r1 + 1 + + // mask is set iff r0 <= (2^(dropped_bits))/2 + mask := subtle.ConstantTimeLessOrEq(int(r0), halfDV) + r0 = fieldElement(subtle.ConstantTimeSelect(mask, int(r0), int(r0Adjusted))) + r1 = fieldElement(subtle.ConstantTimeSelect(mask, int(r1), int(r1Adjusted))) + return +} + +// compressHighBits decomposes r into r1 and r0 such that r == r1 * (2 * gamma2) + r0 mod q. +// See FIPS 204, Algorithm 37, HighBits. +// +// r: The input value to decompose, in the range [0, q-1]. +// gamma2: Depending on the algorithm, gamma2 is either (q-1)/32 or (q-1)/88. +// Returns: r1 (the high-order bits). +func compressHighBits(r fieldElement, gamma2 uint32) uint32 { + // Initial computation of r1 + r1 := int32((r + 127) >> 7) + + if gamma2 == gamma2QMinus1Div32 { + // returns ((ceil(r / 2^7) * (2^10 + 1) + 2^21) / 2^22) mod 2^4 + r1 = (r1*1025 + (1 << 21)) >> 22 + r1 &= 15 // r1 mod 2^4 + return uint32(r1) + } else { + // Adjust r1 for gamma2 = (q-1)/88 + r1 = (r1*11275 + (1 << 23)) >> 24 + // Ensure r1 is within the valid range + r1 ^= ((43 - r1) >> 31) & r1 + return uint32(r1) + } +} + +func decompose(r fieldElement, gamma2 uint32) (r1 uint32, r0 int32) { + r1 = compressHighBits(r, gamma2) + r0 = int32(r) - int32(r1)*int32(gamma2)*2 + r0 -= ((int32(qMinus1Div2) - r0) >> 31) & q + return +} + +// See FIPS 204, Algorithm 40, UseHint(h, r) +func useHint(h, r fieldElement, gamma2 uint32) fieldElement { + r1, r0 := decompose(r, gamma2) + if int(h) == 0 { + return fieldElement(r1) + } + if gamma2 == gamma2QMinus1Div32 { + // m = 16, thus |mod m| in the spec turns into |& 15| + if r0 > 0 { + return fieldElement((r1 + 1) & 15) + } + return fieldElement((r1 - 1) & 15) + } else { + // m = 44 if gamma2 = ((q - 1) / 88) + if r0 > 0 { + if r1 == 43 { + return 0 + } + return fieldElement(r1 + 1) + } else if r1 == 0 { + return 43 + } + return fieldElement(r1 - 1) + } +} diff --git a/mldsa/compress_test.go b/mldsa/compress_test.go new file mode 100644 index 0000000..b319f7b --- /dev/null +++ b/mldsa/compress_test.go @@ -0,0 +1,87 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import ( + "testing" +) + +func _power2Round(r uint32) (r1 uint32, r0 int32) { + const rd = 1 << d + r = r % q + r0 = int32(r % rd) + if r0 > int32(rd/2) { + r0 -= int32(rd) + } + r1 = uint32((int32(r) - r0) / int32(rd)) + if r0 < 0 { + r0 += int32(q) + } + return +} + +func _decompse(r uint32, gamma2 uint32) (r1 uint32, r0 int32) { + r = r % q + r0 = int32(r % (2 * gamma2)) + if r0 > int32(gamma2) { + r0 -= 2 * int32(gamma2) + } + if int32(r)-r0 == q-1 { + r1 = 0 + r0-- + } else { + r1 = uint32(int32(r)-r0) / (2 * gamma2) + } + return +} + +func TestPower2Round(t *testing.T) { + for i := 0; i <= 1000; i++ { + r1, r0 := power2Round(fieldElement(i)) + expectedR1, expectedR0 := _power2Round(uint32(i)) + if r1 != fieldElement(expectedR1) { + t.Errorf("power2Round(%d) = %d, want %d", i, r1, expectedR1) + } + if r0 != fieldElement(expectedR0) { + t.Errorf("power2Round(%d) = %d, want %d", i, r0, expectedR0) + } + } + for i := q - 1001; i < q; i++ { + r1, r0 := power2Round(fieldElement(i)) + expectedR1, expectedR0 := _power2Round(uint32(i)) + if r1 != fieldElement(expectedR1) { + t.Errorf("power2Round(%d) = %d, want %d", i, r1, expectedR1) + } + if r0 != fieldElement(expectedR0) { + t.Errorf("power2Round(%d) = %d, want %d", i, r0, expectedR0) + } + } +} + +func TestDecompose(t *testing.T) { + gammas := []uint32{gamma2QMinus1Div32, gamma2QMinus1Div88} + for _, gamma := range gammas { + for i := 0; i <= 1000; i++ { + r1, r0 := decompose(fieldElement(i), gamma) + expectedR1, expectedR0 := _decompse(uint32(i), gamma) + if r1 != expectedR1 { + t.Errorf("decompose(%d/%d) r1 = %d, want %d", i, gamma, r1, expectedR1) + } + if r0 != expectedR0 { + t.Errorf("decompose(%d/%d) r0 = %d, want %d", i, gamma, r0, expectedR0) + } + } + for i := q - 1001; i < q; i++ { + r1, r0 := decompose(fieldElement(i), gamma) + expectedR1, expectedR0 := _decompse(uint32(i), gamma) + if r1 != expectedR1 { + t.Errorf("decompose(%d/%d) r1 = %d, want %d", i, gamma, r1, expectedR1) + } + if r0 != expectedR0 { + t.Errorf("decompose(%d/%d) r0 = %d, want %d", i, gamma, r0, expectedR0) + } + } + } +} diff --git a/mldsa/encoder.go b/mldsa/encoder.go new file mode 100644 index 0000000..777b8d1 --- /dev/null +++ b/mldsa/encoder.go @@ -0,0 +1,435 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import ( + "crypto/subtle" + "errors" + + "github.com/emmansun/gmsm/internal/alias" +) + +// simpleBitPack10Bits encodes a polynomial f into a byte slice +// +// See FIPS 204, Algorithm 16, SimpleBitPack(w, b) where b = 10 bits +// i.e. Use 10 bits from each coefficient and pack them into bytes +// So every 4 coefficients (c0..c3) fit into 5 bytes. +// +// |c0||c1||c2||c3| +// |\ |\ |\ |\ +// |8|2 6|4 4|6 2|8| +func simpleBitPack10Bits(s []byte, f ringElement) []byte { + s, b := alias.SliceForAppend(s, encodingSize10) + for i := 0; i < n; i += 4 { + var x uint64 + x |= uint64(f[i]) + x |= uint64(f[i+1]) << 10 + x |= uint64(f[i+2]) << 20 + x |= uint64(f[i+3]) << 30 + b[0] = uint8(x) + b[1] = uint8(x >> 8) + b[2] = uint8(x >> 16) + b[3] = uint8(x >> 24) + b[4] = uint8(x >> 32) + b = b[5:] + } + return s +} + +// simpleBitUnpack10Bits decodes a byte slice into a polynomial f +// See FIPS 204, Algorithm 18, SimpleBitUnpack(w, b) where b = 10 bits +func simpleBitUnpack10Bits(b []byte, f *ringElement) { + const mask = 0x3FF + for i := 0; i < n; i += 4 { + x := uint64(b[0]) | (uint64(b[1]) << 8) | (uint64(b[2]) << 16) | (uint64(b[3]) << 24) | (uint64(b[4]) << 32) + b = b[5:] + f[i] = fieldElement(x & mask) + f[i+1] = fieldElement((x >> 10) & mask) + f[i+2] = fieldElement((x >> 20) & mask) + f[i+3] = fieldElement((x >> 30) & mask) + } +} + +// simpleBitPack4Bits encodes a polynomial into a byte string, assuming that all coefficients are +// in the range 0..15 (4 bits). +// +// See FIPS 204, Algorithm 16, SimpleBitPack(w, b) where b = 4 bits +// +// i.e. Use 4 bits from each coefficient and pack them into bytes +// So every 2 coefficients fit into 1 byte. +// +// This is used to encode w1 when signing with ML-DSA-65 and ML-DSA-87 +func simpleBitPack4Bits(s []byte, f ringElement) []byte { + s, b := alias.SliceForAppend(s, encodingSize4) + for i := 0; i < n; i += 2 { + b[0] = uint8(f[i]) | (uint8(f[i+1]) << 4) + b = b[1:] + } + return s +} + +// simpleBitPack6Bits encodes a polynomial into a byte string, assuming that all coefficients are +// in the range 0..43 (6 bits). +// +// See FIPS 204, Algorithm 16, SimpleBitPack(w, b) where b = 43 +// +// i.e. Use 6 bits from each coefficient and pack them into bytes +// So every 4 coefficients fit into 3 bytes. +// +// |c0||c1||c2||c3| +// | /| /\ / +// |6 2|4 4|2 6| +// +// This is used to encode w1 when signing with ML-DSA-44 +func simpleBitPack6Bits(s []byte, f ringElement) []byte { + s, b := alias.SliceForAppend(s, encodingSize6) + for i := 0; i < n; i += 4 { + var x uint64 + x = uint64(f[i]) + x |= uint64(f[i+1]) << 6 + x |= uint64(f[i+2]) << 12 + x |= uint64(f[i+3]) << 18 + b[0] = uint8(x) + b[1] = uint8(x >> 8) + b[2] = uint8(x >> 16) + + b = b[3:] + } + return s +} + +// bitPackSigned2 encodes a polynomial f into a byte slice, assuming that all +// coefficients are in the range -2..2. +// See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = b = 2. +// +// This is used to encode the private key polynomial elements of s1 and s2 +// for ML-DSA-44 and ML-DSA-87 (i.e. eta = 2) +// Use 3 bits from each coefficient and pack them into bytes +// So every 8 coefficients fit into 3 bytes. +// +// |c0 c1 c2 c3 c4 c5 c6 c7| +// | / / | | / / | | / +// |3 3 2| 1 3 3 1| 2 3 3| +func bitPackSigned2(s []byte, f ringElement) []byte { + s, b := alias.SliceForAppend(s, encodingSize3) + for i := 0; i < n; i += 8 { + var x uint32 + x |= uint32(fieldSub(2, f[i])) + x |= uint32(fieldSub(2, f[i+1])) << 3 + x |= uint32(fieldSub(2, f[i+2])) << 6 + x |= uint32(fieldSub(2, f[i+3])) << 9 + x |= uint32(fieldSub(2, f[i+4])) << 12 + x |= uint32(fieldSub(2, f[i+5])) << 15 + x |= uint32(fieldSub(2, f[i+6])) << 18 + x |= uint32(fieldSub(2, f[i+7])) << 21 + b[0] = uint8(x) + b[1] = uint8(x >> 8) + b[2] = uint8(x >> 16) + b = b[3:] + } + return s +} + +// bitUnpackSigned2 decodes a byte slice into a polynomial f +// See FIPS 204, Algorithm 19, BitUnpack(w, a, b). where a = b = 2. +func bitUnpackSigned2(b []byte) (ringElement, error) { + const bitsMask = 0x7 + var f ringElement + for i := 0; i < n; i += 8 { + x := uint32(b[0]) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) + msbs := x & 0o44444444 + mask := (msbs >> 1) | (msbs >> 2) + if subtle.ConstantTimeEq(int32(mask&x), 0) == 0 { + return ringElement{}, errors.New("mldsa: invalid encoding") + } + + b = b[3:] + f[i] = fieldSub(2, fieldElement(x&bitsMask)) + f[i+1] = fieldSub(2, fieldElement((x>>3)&bitsMask)) + f[i+2] = fieldSub(2, fieldElement((x>>6)&bitsMask)) + f[i+3] = fieldSub(2, fieldElement((x>>9)&bitsMask)) + f[i+4] = fieldSub(2, fieldElement((x>>12)&bitsMask)) + f[i+5] = fieldSub(2, fieldElement((x>>15)&bitsMask)) + f[i+6] = fieldSub(2, fieldElement((x>>18)&bitsMask)) + f[i+7] = fieldSub(2, fieldElement((x>>21)&bitsMask)) + } + return f, nil +} + + +// bitPackSigned4 encodes a polynomial into a byte string, assuming that all +// coefficients are in the range -4..4. +// See FIPS 204, Algorithm 17, BitPack(w, a, b). (a = 4, b = 4) +// +// It uses a nibble from each coefficient and packs them into bytes +// So every 2 coefficients fit into 1 byte. +// +// This is used to encode the private key polynomial elements of s1 and s2 +// for ML-DSA-65 (i.e. eta = 4) +func bitPackSigned4(s []byte, f ringElement) []byte { + s, b := alias.SliceForAppend(s, encodingSize4) + for i := 0; i < n; i += 2 { + b[0] = uint8(fieldSub(4, f[i])) | (uint8(fieldSub(4, f[i+1])) << 4) + b = b[1:] + } + return s +} + +// bitUnpackSigned4 reverses the procedure of bitPackSigned4(). +// See FIPS 204, Algorithm 19, BitUnpack(v, a, b) where a = b = 4. +func bitUnpackSigned4(b []byte) (ringElement, error) { + const bitsMask = 0xF + var f ringElement + for i := 0; i < n; i += 8 { + x := uint32(b[0]) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24) + // None of the nibbles may be >= 9. So if the MSB of any nibble is set, + // none of the other bits may be set. First, select all the MSBs. + msbs := x & 0x88888888 + // For each nibble where the MSB is set, form a mask of all the other bits. + mask := (msbs >> 1) | (msbs >> 2) | (msbs >> 3) + if subtle.ConstantTimeEq(int32(mask&x), 0) == 0 { + return ringElement{}, errors.New("mldsa: invalid encoding") + } + + b = b[4:] + f[i] = fieldSub(4, fieldElement(x&bitsMask)) + f[i+1] = fieldSub(4, fieldElement((x>>4)&bitsMask)) + f[i+2] = fieldSub(4, fieldElement((x>>8)&bitsMask)) + f[i+3] = fieldSub(4, fieldElement((x>>12)&bitsMask)) + f[i+4] = fieldSub(4, fieldElement((x>>16)&bitsMask)) + f[i+5] = fieldSub(4, fieldElement((x>>20)&bitsMask)) + f[i+6] = fieldSub(4, fieldElement((x>>24)&bitsMask)) + f[i+7] = fieldSub(4, fieldElement((x>>28)&bitsMask)) + } + return f, nil +} + + +// bitPackSigned4196 encodes a polynomial f into a byte slice, assuming that all +// coefficients are in the range (-2^12 + 1)..2^12. +// See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = 2^12 - 1, b = 2^12. +// +// This is used to encode the LSB of the public key polynomial elements of t0 +// which are encoded as part of the encoded private key. +// +// The code below packs them into 2 64 bits blocks by doing.. +// +// z0 z1 z2 z3 z4 z5 z6 z7 0 +// | | | | / \ | | | | +// +// |13 13 13 13 12 |1 13 13 13 24 +func bitPackSigned4096(s []byte, f ringElement) []byte { + const r = 4096 // 2^12 + s, b := alias.SliceForAppend(s, encodingSize13) + for i := 0; i < n; i += 8 { + var x1, x2, a uint64 + x1 = uint64(fieldSub(r, f[i])) + x1 |= uint64(fieldSub(r, f[i+1])) << 13 + x1 |= uint64(fieldSub(r, f[i+2])) << 26 + x1 |= uint64(fieldSub(r, f[i+3])) << 39 + a = uint64(fieldSub(r, f[i+4])) + x1 |= a << 52 + x2 = a >> 12 + x2 |= uint64(fieldSub(r, f[i+5])) << 1 + x2 |= uint64(fieldSub(r, f[i+6])) << 14 + x2 |= uint64(fieldSub(r, f[i+7])) << 27 + b[0] = uint8(x1) + b[1] = uint8(x1 >> 8) + b[2] = uint8(x1 >> 16) + b[3] = uint8(x1 >> 24) + b[4] = uint8(x1 >> 32) + b[5] = uint8(x1 >> 40) + b[6] = uint8(x1 >> 48) + b[7] = uint8(x1 >> 56) + b[8] = uint8(x2) + b[9] = uint8(x2 >> 8) + b[10] = uint8(x2 >> 16) + b[11] = uint8(x2 >> 24) + b[12] = uint8(x2 >> 32) + + b = b[13:] + } + return s +} + +// bitUnpackSigned4096 decodes a byte slice into a polynomial f +// See FIPS 204, Algorithm 19, BitUnpack(w, a, b). where a = 2^12 - 1, b = 2^12. +func bitUnpackSigned4096(b []byte, f *ringElement) error { + const bitsMask = 0x1FFF // 2^13-1 + const r = 4096 // 2^12 + for i := 0; i < n; i += 8 { + x1 := uint64(b[0]) | (uint64(b[1]) << 8) | (uint64(b[2]) << 16) | (uint64(b[3]) << 24) | (uint64(b[4]) << 32) | (uint64(b[5]) << 40) | (uint64(b[6]) << 48) | (uint64(b[7]) << 56) + x2 := uint64(b[8]) | (uint64(b[9]) << 8) | (uint64(b[10]) << 16) | (uint64(b[11]) << 24) | (uint64(b[12]) << 32) + b = b[13:] + f[i] = fieldSub(r, fieldElement(x1&bitsMask)) + f[i+1] = fieldSub(r, fieldElement((x1>>13)&bitsMask)) + f[i+2] = fieldSub(r, fieldElement((x1>>26)&bitsMask)) + f[i+3] = fieldSub(r, fieldElement((x1>>39)&bitsMask)) + f[i+4] = fieldSub(r, fieldElement((x1>>52 | (x2 << 12 & bitsMask)))) + f[i+5] = fieldSub(r, fieldElement((x2>>1)&bitsMask)) + f[i+6] = fieldSub(r, fieldElement((x2>>14)&bitsMask)) + f[i+7] = fieldSub(r, fieldElement((x2>>27)&bitsMask)) + } + return nil +} + +// bitPackSignedTwoPower17 encodes a polynomial into a byte string, assuming that all +// coefficients are in the range (-2^17 + 1)..2^17. +// See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = 2^17 - 1, b = 2^17. +// +// This is used to encode signatures for ML-DSA-44 (where gamma1 = 2^17) +// +// # Use 18 bits from each coefficient and pack them into bytes +// +// The code below packs every 4 (18 bit) coefficients into 9 bytes +// +// z0 z1 z2 z3 +// | |\ | | \ +// +// |18 14|4 18 10| 8 +func bitPackSignedTwoPower17(s []byte, f ringElement) []byte { + const r = 131072 // 2^17 + s, b := alias.SliceForAppend(s, encodingSize18) + for i := 0; i < n; i += 4 { + var x1, x2 uint64 + x1 = uint64(fieldSub(r, f[i])) + x1 |= uint64(fieldSub(r, f[i+1])) << 18 + x1 |= uint64(fieldSub(r, f[i+2])) << 36 + x2 = uint64(fieldSub(r, f[i+3])) + x1 |= x2 << 54 + x2 >>= 10 + b[0] = uint8(x1) + b[1] = uint8(x1 >> 8) + b[2] = uint8(x1 >> 16) + b[3] = uint8(x1 >> 24) + b[4] = uint8(x1 >> 32) + b[5] = uint8(x1 >> 40) + b[6] = uint8(x1 >> 48) + b[7] = uint8(x1 >> 56) + b[8] = uint8(x2) + + b = b[9:] + } + return s +} + +// bitUnpackSignedTwoPower17 decodes a byte slice into a polynomial f +// See FIPS 204, Algorithm 19, BitUnpack(w, a, b). where a = 2^17 - 1, b = 2^17. +func bitUnpackSignedTwoPower17(b []byte, f *ringElement) { + const bitsMask = 0x3FFFF // 2^18-1 + const r = 131072 // 2^17 + for i := 0; i < n; i += 4 { + x1 := uint64(b[0]) | (uint64(b[1]) << 8) | (uint64(b[2]) << 16) | (uint64(b[3]) << 24) | (uint64(b[4]) << 32) | (uint64(b[5]) << 40) | (uint64(b[6]) << 48) | (uint64(b[7]) << 56) + x2 := uint64(b[8]) + b = b[9:] + f[i] = fieldSub(r, fieldElement(x1&bitsMask)) + f[i+1] = fieldSub(r, fieldElement((x1>>18)&bitsMask)) + f[i+2] = fieldSub(r, fieldElement((x1>>36)&bitsMask)) + f[i+3] = fieldSub(r, fieldElement((x1>>54 | (x2 << 10 & bitsMask)))) + } +} + +// bitPackSignedTwoPower19 encodes a polynomial into a byte string, assuming that all +// coefficients are in the range (-2^19 + 1)..2^19. +// See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = 2^19 - 1, b = 2^19. +// +// This is used to encode signatures for ML-DSA-65 & ML-DSA-87 (gamma1 = 2^19) +// +// # Use 20 bits from each coefficient and pack them into bytes +// +// The code below packs every 4 (20 bit) coefficients into 10 bytes +// +// z0 z1 z2 z3 +// | |\ | | \ +// +// |20 12|8 20 4|16 +func bitPackSignedTwoPower19(s []byte, f ringElement) []byte { + const r = 524288 // 2^19 + s, b := alias.SliceForAppend(s, encodingSize20) + for i := 0; i < n; i += 4 { + var x1, x2 uint64 + x1 = uint64(fieldSub(r, f[i])) + x1 |= uint64(fieldSub(r, f[i+1])) << 20 + x1 |= uint64(fieldSub(r, f[i+2])) << 40 + x2 = uint64(fieldSub(r, f[i+3])) + x1 |= x2 << 60 + x2 >>= 4 + b[0] = uint8(x1) + b[1] = uint8(x1 >> 8) + b[2] = uint8(x1 >> 16) + b[3] = uint8(x1 >> 24) + b[4] = uint8(x1 >> 32) + b[5] = uint8(x1 >> 40) + b[6] = uint8(x1 >> 48) + b[7] = uint8(x1 >> 56) + b[8] = uint8(x2) + b[9] = uint8(x2 >> 8) + + b = b[10:] + } + return s +} + +// bitUnpackSignedTwoPower19 decodes a byte slice into a polynomial f +// See FIPS 204, Algorithm 19, BitUnpack(w, a, b). where a = 2^19 - 1, b = 2^19. +// The coefficients are in the range (-2^19 + 1)..2^19 +// and are represented as 20 bits. +func bitUnpackSignedTwoPower19(b []byte, f *ringElement) { + const bitsMask = 0xFFFFF // 2^20-1 + const r = 524288 // 2^19 + for i := 0; i < n; i += 4 { + x1 := uint64(b[0]) | (uint64(b[1]) << 8) | (uint64(b[2]) << 16) | (uint64(b[3]) << 24) | (uint64(b[4]) << 32) | (uint64(b[5]) << 40) | (uint64(b[6]) << 48) | (uint64(b[7]) << 56) + x2 := uint64(b[8]) | (uint64(b[9]) << 8) + b = b[10:] + f[i] = fieldSub(r, fieldElement(x1&bitsMask)) + f[i+1] = fieldSub(r, fieldElement((x1>>20)&bitsMask)) + f[i+2] = fieldSub(r, fieldElement((x1>>40)&bitsMask)) + f[i+3] = fieldSub(r, fieldElement((x1>>60 | (x2 << 4 & bitsMask)))) + } +} + +// See FIPS 204, Algorithm 20, HintBitPack(). +func hintBitPack(s []byte, hint []ringElement, omega int) []byte { + k := len(hint) + s, b := alias.SliceForAppend(s, omega+k) + index := 0 + for i := range k { + for j := 0; j < n; j++ { + if hint[i][j] != 0 { + b[index] = byte(j) + index++ + } + } + b[omega+i] = byte(index) + } + return s +} + +// See FIPS 204, Algorithm 21, HintBitUnpack(). +func hintBitUnpack(b []byte, hint []ringElement, omega int) bool { + k := len(hint) + index := 0 + first := 0 + for i := range k { + limit := int(b[omega+i]) + if limit < index || limit > omega { + return false + } + first = index + for ; index < limit; index++ { + bi := b[index] + if index > first && b[index-1] >= bi { + return false + } + hint[i][bi] = 1 + } + } + for i := index; i < omega; i++ { + if b[i] != 0 { + return false + } + } + return true +} diff --git a/mldsa/field.go b/mldsa/field.go new file mode 100644 index 0000000..526bc87 --- /dev/null +++ b/mldsa/field.go @@ -0,0 +1,254 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import ( + "crypto/subtle" +) + +// fieldElement is an integer modulo q, an element of ℤ_q. It is always reduced. +type fieldElement uint32 + +// fieldCheckReduced checks that a value a is < q. +//func fieldCheckReduced(a uint32) (fieldElement, error) { +// if a >= q { +// return 0, errors.New("unreduced field element") +// } +// return fieldElement(a), nil +//} + +// fieldReduceOnce reduces a value a < 2q. +func fieldReduceOnce(a uint32) fieldElement { + x := a - q + // If x underflowed, then x >= 2^32 - q > 2^31, so the top bit is set. + x += (x >> 31) * q + return fieldElement(x) +} + +func fieldAdd(a, b fieldElement) fieldElement { + x := uint32(a + b) + return fieldReduceOnce(x) +} + +func fieldSub(a, b fieldElement) fieldElement { + x := uint32(a - b + q) + return fieldReduceOnce(x) +} + +const ( + qInv = 58728449 + qNegInv = 4236238847 + r = 4193792 // 2^32 mod q +) + +func fieldReduce(a uint64) fieldElement { + t := uint32(a) * qNegInv + return fieldReduceOnce(uint32((a + uint64(t)*q) >> 32)) +} + +func fieldMul(a, b fieldElement) fieldElement { + x := uint64(a) * uint64(b) + return fieldReduce(x) +} + +// fieldMulSub returns a * (b - c). This operation is fused to save a +// fieldReduceOnce after the subtraction. +func fieldMulSub(a, b, c fieldElement) fieldElement { + x := uint64(a) * uint64(b-c+q) + return fieldReduce(x) +} + +// ringElement is a polynomial, an element of R_q, represented as an array. +type ringElement [n]fieldElement + +// polyAdd adds two ringElements or nttElements. +func polyAdd[T ~[n]fieldElement](a, b T) (s T) { + for i := range s { + s[i] = fieldAdd(a[i], b[i]) + } + return s +} + +// polySub subtracts two ringElements or nttElements. +func polySub[T ~[n]fieldElement](a, b T) (s T) { + for i := range s { + s[i] = fieldSub(a[i], b[i]) + } + return s +} + +// nttElement is an NTT representation, an element of T_q, represented as an array. +type nttElement [n]fieldElement + +// The table in FIPS 204 Appendix B uses the following formula +// zeta[k]= 1753^bitrev(k) mod q for (k = 1..255) (The first value is not used). +// +// As this implementation uses montgomery form with a multiplier of 2^32. +// The values need to be transformed i.e. +// +// zetasMontgomery[k] = fieldReduce(zeta[k] * (2^32 * 2^32 mod(q))) +var zetasMontgomery = [n]fieldElement{ + 4193792, 25847, 5771523, 7861508, 237124, 7602457, 7504169, 466468, + 1826347, 2353451, 8021166, 6288512, 3119733, 5495562, 3111497, 2680103, + 2725464, 1024112, 7300517, 3585928, 7830929, 7260833, 2619752, 6271868, + 6262231, 4520680, 6980856, 5102745, 1757237, 8360995, 4010497, 280005, + 2706023, 95776, 3077325, 3530437, 6718724, 4788269, 5842901, 3915439, + 4519302, 5336701, 3574422, 5512770, 3539968, 8079950, 2348700, 7841118, + 6681150, 6736599, 3505694, 4558682, 3507263, 6239768, 6779997, 3699596, + 811944, 531354, 954230, 3881043, 3900724, 5823537, 2071892, 5582638, + 4450022, 6851714, 4702672, 5339162, 6927966, 3475950, 2176455, 6795196, + 7122806, 1939314, 4296819, 7380215, 5190273, 5223087, 4747489, 126922, + 3412210, 7396998, 2147896, 2715295, 5412772, 4686924, 7969390, 5903370, + 7709315, 7151892, 8357436, 7072248, 7998430, 1349076, 1852771, 6949987, + 5037034, 264944, 508951, 3097992, 44288, 7280319, 904516, 3958618, + 4656075, 8371839, 1653064, 5130689, 2389356, 8169440, 759969, 7063561, + 189548, 4827145, 3159746, 6529015, 5971092, 8202977, 1315589, 1341330, + 1285669, 6795489, 7567685, 6940675, 5361315, 4499357, 4751448, 3839961, + 2091667, 3407706, 2316500, 3817976, 5037939, 2244091, 5933984, 4817955, + 266997, 2434439, 7144689, 3513181, 4860065, 4621053, 7183191, 5187039, + 900702, 1859098, 909542, 819034, 495491, 6767243, 8337157, 7857917, + 7725090, 5257975, 2031748, 3207046, 4823422, 7855319, 7611795, 4784579, + 342297, 286988, 5942594, 4108315, 3437287, 5038140, 1735879, 203044, + 2842341, 2691481, 5790267, 1265009, 4055324, 1247620, 2486353, 1595974, + 4613401, 1250494, 2635921, 4832145, 5386378, 1869119, 1903435, 7329447, + 7047359, 1237275, 5062207, 6950192, 7929317, 1312455, 3306115, 6417775, + 7100756, 1917081, 5834105, 7005614, 1500165, 777191, 2235880, 3406031, + 7838005, 5548557, 6709241, 6533464, 5796124, 4656147, 594136, 4603424, + 6366809, 2432395, 2454455, 8215696, 1957272, 3369112, 185531, 7173032, + 5196991, 162844, 1616392, 3014001, 810149, 1652634, 4686184, 6581310, + 5341501, 3523897, 3866901, 269760, 2213111, 7404533, 1717735, 472078, + 7953734, 1723600, 6577327, 1910376, 6712985, 7276084, 8119771, 4546524, + 5441381, 6144432, 7959518, 6094090, 183443, 7403526, 1612842, 4834730, + 7826001, 3919660, 8332111, 7018208, 3937738, 1400424, 7534263, 1976782, +} + +// ntt maps a ringElement to its nttElement representation. +// +// It implements NTT, according to FIPS 204, Algorithm 41. +func ntt(f ringElement) nttElement { + k := 1 + // len: 128, 64, 32, ..., 1 + for len := 128; len >= 1; len /= 2 { + // start + for start := 0; start < 256; start += 2 * len { + zeta := zetasMontgomery[k] + k++ + // Bounds check elimination hint. + f, flen := f[start:start+len], f[start+len:start+len+len] + for j := range len { + t := fieldMul(zeta, flen[j]) + flen[j] = fieldSub(f[j], t) + f[j] = fieldAdd(f[j], t) + } + } + } + return nttElement(f) +} + +// inverseNTT maps a nttElement back to the ringElement it represents. +// +// It implements NTT⁻¹, according to FIPS 204, Algorithm 42. +func inverseNTT(f nttElement) ringElement { + k := 255 + for len := 1; len < 256; len *= 2 { + for start := 0; start < 256; start += 2 * len { + zeta := q - zetasMontgomery[k] + k-- + // Bounds check elimination hint. + f, flen := f[start:start+len], f[start+len:start+len+len] + for j := range len { + t := f[j] + f[j] = fieldAdd(t, flen[j]) + flen[j] = fieldMulSub(zeta, t, flen[j]) + } + } + } + for i := range f { + f[i] = fieldMul(f[i], 41978) // 41978 = ((256⁻¹ mod q) * (2^64 mode q)) mode q + } + return ringElement(f) +} + +func nttMul(f, g nttElement) nttElement { + var ret nttElement + for i, v := range f { + ret[i] = fieldMul(v, g[i]) + } + return ret +} + +// infinityNorm returns the absolute value modulo q in constant time +// +// i.e return x > (q - 1) / 2 ? q - x : x; +func infinityNorm(a fieldElement) uint32 { + ret := subtle.ConstantTimeLessOrEq(int(a), qMinus1Div2) + return uint32(subtle.ConstantTimeSelect(ret, int(a), int(q-a))) +} + +func polyInfinityNorm[T ~[n]fieldElement](a T, norm int) int { + for i := range a { + left := int(infinityNorm(a[i])) + right := int(norm) + norm = subtle.ConstantTimeSelect(subtle.ConstantTimeLessOrEq(left, right), right, left) + } + return norm +} + +func vectorInfinityNorm[T ~[n]fieldElement](a []T, norm int) int { + for i := range a { + left := int(polyInfinityNorm(a[i], norm)) + right := int(norm) + norm = subtle.ConstantTimeSelect(subtle.ConstantTimeLessOrEq(left, right), right, left) + } + return norm +} + +func infinityNormSigned(a int32) int { + ret := subtle.ConstantTimeLessOrEq(0x80000000, int(a)) + return subtle.ConstantTimeSelect(ret, int(-a), int(a)) +} + +func polyInfinityNormSigned(a []int32, norm int) int { + for i := range a { + left := int(infinityNormSigned(a[i])) + right := norm + norm = subtle.ConstantTimeSelect(subtle.ConstantTimeLessOrEq(left, right), right, left) + } + return norm +} + +func vectorInfinityNormSigned(a [][n]int32, norm int) int { + for i := range a { + left := int(polyInfinityNormSigned(a[i][:], norm)) + right := norm + norm = subtle.ConstantTimeSelect(subtle.ConstantTimeLessOrEq(left, right), right, left) + } + return norm +} + +func vectorCountOnes(a []ringElement) int { + var oneCount int + for i := range a { + for j := range a[i] { + oneCount += int(a[i][j]) + } + } + return oneCount +} + +func vectorMakeHint(ct0, cs2, w, hint []ringElement, gamma2 uint32) { + for i := range ct0 { + for j := range ct0[i] { + hint[i][j] = makeHint(ct0[i][j], cs2[i][j], w[i][j], gamma2) + } + } +} + +func makeHint(ct0, cs2, w fieldElement, gamma2 uint32) fieldElement { + rPulusZ := fieldSub(w, cs2) + r := fieldAdd(rPulusZ, ct0) + + return fieldElement(1 ^ uint32(subtle.ConstantTimeEq(int32(compressHighBits(r, gamma2)), int32(compressHighBits(rPulusZ, gamma2))))) +} diff --git a/mldsa/field_barrett.go b/mldsa/field_barrett.go new file mode 100644 index 0000000..3a88114 --- /dev/null +++ b/mldsa/field_barrett.go @@ -0,0 +1,112 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import "math/bits" + +const ( + barrettMultiplier = 8396807 // 2^23 * 2^23 / q + barrettShift = 46 // log₂(2^23 * 2^23) +) + +func fieldBarrettReduce(a uint64) fieldElement { + hi, low := bits.Mul64(a, barrettMultiplier) + quotient := hi<<18 | low>>barrettShift + return fieldReduceOnce(uint32(a - quotient*q)) +} + +func fieldBarrettMul(a, b fieldElement) fieldElement { + x := uint64(a) * uint64(b) + return fieldBarrettReduce(x) +} + +func fieldBarrettMulSub(a, b, c fieldElement) fieldElement { + x := uint64(a) * uint64(b-c+q) + return fieldBarrettReduce(x) +} + +var zetas = [n]fieldElement{ + 1, 4808194, 3765607, 3761513, 5178923, 5496691, 5234739, 5178987, + 7778734, 3542485, 2682288, 2129892, 3764867, 7375178, 557458, 7159240, + 5010068, 4317364, 2663378, 6705802, 4855975, 7946292, 676590, 7044481, + 5152541, 1714295, 2453983, 1460718, 7737789, 4795319, 2815639, 2283733, + 3602218, 3182878, 2740543, 4793971, 5269599, 2101410, 3704823, 1159875, + 394148, 928749, 1095468, 4874037, 2071829, 4361428, 3241972, 2156050, + 3415069, 1759347, 7562881, 4805951, 3756790, 6444618, 6663429, 4430364, + 5483103, 3192354, 556856, 3870317, 2917338, 1853806, 3345963, 1858416, + 3073009, 1277625, 5744944, 3852015, 4183372, 5157610, 5258977, 8106357, + 2508980, 2028118, 1937570, 4564692, 2811291, 5396636, 7270901, 4158088, + 1528066, 482649, 1148858, 5418153, 7814814, 169688, 2462444, 5046034, + 4213992, 4892034, 1987814, 5183169, 1736313, 235407, 5130263, 3258457, + 5801164, 1787943, 5989328, 6125690, 3482206, 4197502, 7080401, 6018354, + 7062739, 2461387, 3035980, 621164, 3901472, 7153756, 2925816, 3374250, + 1356448, 5604662, 2683270, 5601629, 4912752, 2312838, 7727142, 7921254, + 348812, 8052569, 1011223, 6026202, 4561790, 6458164, 6143691, 1744507, + 1753, 6444997, 5720892, 6924527, 2660408, 6600190, 8321269, 2772600, + 1182243, 87208, 636927, 4415111, 4423672, 6084020, 5095502, 4663471, + 8352605, 822541, 1009365, 5926272, 6400920, 1596822, 4423473, 4620952, + 6695264, 4969849, 2678278, 4611469, 4829411, 635956, 8129971, 5925040, + 4234153, 6607829, 2192938, 6653329, 2387513, 4768667, 8111961, 5199961, + 3747250, 2296099, 1239911, 4541938, 3195676, 2642980, 1254190, 8368000, + 2998219, 141835, 8291116, 2513018, 7025525, 613238, 7070156, 6161950, + 7921677, 6458423, 4040196, 4908348, 2039144, 6500539, 7561656, 6201452, + 6757063, 2105286, 6006015, 6346610, 586241, 7200804, 527981, 5637006, + 6903432, 1994046, 2491325, 6987258, 507927, 7192532, 7655613, 6545891, + 5346675, 8041997, 2647994, 3009748, 5767564, 4148469, 749577, 4357667, + 3980599, 2569011, 6764887, 1723229, 1665318, 2028038, 1163598, 5011144, + 3994671, 8368538, 7009900, 3020393, 3363542, 214880, 545376, 7609976, + 3105558, 7277073, 508145, 7826699, 860144, 3430436, 140244, 6866265, + 6195333, 3123762, 2358373, 6187330, 5365997, 6663603, 2926054, 7987710, + 8077412, 3531229, 4405932, 4606686, 1900052, 7598542, 1054478, 7648983, +} + +func barrettNTT(f ringElement) nttElement { + k := 1 + // len: 128, 64, 32, ..., 1 + for len := 128; len >= 1; len /= 2 { + // start + for start := 0; start < 256; start += 2 * len { + zeta := zetas[k] + k++ + // Bounds check elimination hint. + f, flen := f[start:start+len], f[start+len:start+len+len] + for j := range len { + t := fieldBarrettMul(zeta, flen[j]) + flen[j] = fieldSub(f[j], t) + f[j] = fieldAdd(f[j], t) + } + } + } + return nttElement(f) +} + +func inverseBarrettNTT(f nttElement) ringElement { + k := 255 + for len := 1; len < 256; len *= 2 { + for start := 0; start < 256; start += 2 * len { + zeta := q - zetas[k] + k-- + // Bounds check elimination hint. + f, flen := f[start:start+len], f[start+len:start+len+len] + for j := range len { + t := f[j] + f[j] = fieldAdd(t, flen[j]) + flen[j] = fieldBarrettMulSub(zeta, t, flen[j]) + } + } + } + for i := range f { + f[i] = fieldBarrettMul(f[i], 8347681) // 8347681 = 256⁻¹ mod q + } + return ringElement(f) +} + +//func nttBarrettMul(f, g nttElement) nttElement { +// var ret nttElement +// for i, v := range f { +// ret[i] = fieldBarrettMul(v, g[i]) +// } +// return ret +//} diff --git a/mldsa/field_test.go b/mldsa/field_test.go new file mode 100644 index 0000000..533962b --- /dev/null +++ b/mldsa/field_test.go @@ -0,0 +1,179 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package mldsa + +import ( + "fmt" + mathrand "math/rand/v2" + "testing" +) + +func TestFieldAdd(t *testing.T) { + for a := fieldElement(q - 1000); a < q; a++ { + for b := fieldElement(q - 1000); b < q; b++ { + got := fieldAdd(a, b) + exp := (a + b) % q + if got != exp { + t.Fatalf("%d + %d = %d, expected %d", a, b, got, exp) + } + } + } +} + +func TestFieldSub(t *testing.T) { + for a := fieldElement(0); a < 2000; a++ { + for b := fieldElement(q - 1000); b < q; b++ { + got := fieldSub(a, b) + exp := (a - b + q) % q + if got != exp { + t.Fatalf("%d - %d = %d, expected %d", a, b, got, exp) + } + } + } +} + +func TestFieldMul(t *testing.T) { + for a := fieldElement(q - 1000); a < q; a++ { + for b := fieldElement(q - 1000); b < q; b++ { + got := fieldMul(fieldElement((uint64(a)*uint64(r))%q), b) + exp := fieldElement((uint64(a) * uint64(b)) % q) + if got != exp { + t.Fatalf("%d * %d = %d, expected %d", a, b, got, exp) + } + } + } + for _, z := range zetasMontgomery { + fmt.Printf("%v, ", fieldReduce(uint64(z))) + } + fmt.Println() +} + +func TestFieldBarrettMul(t *testing.T) { + for a := fieldElement(q - 1000); a < q; a++ { + for b := fieldElement(q - 1000); b < q; b++ { + got := fieldBarrettMul(a, b) + exp := fieldElement((uint64(a) * uint64(b)) % q) + if got != exp { + t.Fatalf("%d * %d = %d, expected %d", a, b, got, exp) + } + } + } +} + +func randomRingElement() ringElement { + var r ringElement + for i := range r { + r[i] = fieldElement(mathrand.IntN(q)) + } + return r +} + +func TestNTT(t *testing.T) { + r := randomRingElement() + r1 := r + r2 := ntt(r) + r3 := barrettNTT(r1) + for i, v := range r3 { + if v != r2[i] { + t.Errorf("expected %v, got %v", v, r2[i]) + } + } +} + +func TestInverseNTT(t *testing.T) { + r := randomRingElement() + r1 := r + r2 := ntt(r1) + r3 := inverseNTT(r2) + for i, v := range r { + if v != fieldReduce(uint64(r3[i])) { + t.Errorf("expected %v, got %v", v, fieldReduce(uint64(r3[i]))) + } + } +} + +func TestInverseBarrettNTT(t *testing.T) { + r := randomRingElement() + r1 := r + r2 := barrettNTT(r1) + r3 := inverseBarrettNTT(r2) + for i, v := range r { + if v != r3[i] { + t.Errorf("expected %v, got %v", v, r3[i]) + } + } +} + +func TestInfinityNorm(t *testing.T) { + cases := []struct { + input fieldElement + expected uint32 + }{ + {0, 0}, + {1, 1}, + {(q - 1) / 2, (q - 1) / 2}, + {(q-1)/2 + 1, q - 1 - (q-1)/2}, + {q - 1, 1}, + } + for _, c := range cases { + got := infinityNorm(c.input) + if got != c.expected { + t.Fatalf("infinityNorm(%d) = %d, expected %d", c.input, got, c.expected) + } + } +} + +func TestPolyInfinityNorm(t *testing.T) { + r := randomRingElement() + got := polyInfinityNorm(r, 0) + var expected int + + for _, v := range r { + if v > qMinus1Div2 { + v = q - v + } + if int(v) > expected { + expected = int(v) + } + } + if got != expected { + t.Fatalf("polyInfinityNorm(%v) = %d, expected %d", r, got, expected) + } +} + +func TestInfinityNormSigned(t *testing.T) { + cases := []struct { + input int32 + expected int + }{ + {0, 0}, + {1, 1}, + {-1, 1}, + {-2, 2}, + } + for _, c := range cases { + got := infinityNormSigned(c.input) + if got != c.expected { + t.Fatalf("infinityNormSigned(%d) = %d, expected %d", c.input, got, c.expected) + } + } +} + +func TestPolyInfinityNormSigned(t *testing.T) { + cases := []struct { + input []int32 + expected int + }{ + {[]int32{0, 0, 0}, 0}, + {[]int32{1, 2, 3}, 3}, + {[]int32{0, -1, -2, -3, 2}, 3}, + } + for _, c := range cases { + got := polyInfinityNormSigned(c.input, 0) + if got != c.expected { + t.Fatalf("polyInfinityNormSigned(%v) = %d, expected %d", c.input, got, c.expected) + } + } +} diff --git a/mldsa/mldsa44.go b/mldsa/mldsa44.go new file mode 100644 index 0000000..e1ce85b --- /dev/null +++ b/mldsa/mldsa44.go @@ -0,0 +1,585 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +// Package mldsa implements the quantum-resistant digital signature algorithm +// ML-DSA (Module-Lattice-Based Digital Signature Standard) as specified in [NIST FIPS 204]. +// +// [NIST FIPS 204]: https://doi.org/10.6028/NIST.FIPS.204 +// +// This implementations referenced OpenSSL's implementation of ML-DSA and part of Golang ML-KEM +// [OpenSSL ML-DSA]: https://github.com/openssl/openssl/blob/master/crypto/ml_dsa +// [Golang ML-KEM]: https://github.com/golang/go/blob/master/src/crypto/internal/fips140/mlkem +package mldsa + +import ( + "crypto" + "crypto/sha3" + "crypto/subtle" + "errors" + "io" +) + +const ( + // ML-DSA global constants. + n = 256 + q = 8380417 // 2^23 - 2^13 + 1 + qMinus1Div2 = (q - 1) / 2 + d = 13 // # of dropped bits from t + + encodingSize10 = n * 10 / 8 // encoding size for bitlen=10 + encodingSize3 = n * 3 / 8 // encoding size for bitlen=3 + encodingSize4 = n * 4 / 8 // encoding size for bitlen=4 + encodingSize6 = n * 6 / 8 // encoding size for bitlen=6 + encodingSize13 = n * 13 / 8 // encoding size for bitlen=13 + encodingSize18 = n * 18 / 8 // encoding size for bitlen=18 + encodingSize20 = n * 20 / 8 // encoding size for bitlen=20 + + SeedSize = 32 + + gamma2QMinus1Div88 = (q - 1) / 88 // low-order rounding range for ML-DSA-44 + gamma2QMinus1Div32 = (q - 1) / 32 // low-order rounding range for ML-DSA-65 and ML-DSA-87 + + gamma1TwoPower17 = 1 << 17 // coefficient range of y for ML-DSA-44 + gamma1TwoPower19 = 1 << 19 // coefficient range of y for ML-DSA-65 and ML-DSA-87 + + eta2 = 2 // private key range for ML-DSA-44 and ML-DSA-87 + bitLenOfETA2 = 3 + eta4 = 4 // private key range for ML-DSA-65 + bitLenOfETA4 = 4 + + lambda128 = 128 // collision strengh of c tilde for ML-DSA-44 + lambda192 = 192 // collision strength of c tilde for ML-DSA-65 + lambda256 = 256 // collision strength of c tilde for ML-DSA-87 + + tau39 = 39 // security parameter for ML-DSA-44 + tau49 = 49 // security parameter for ML-DSA-65 + tau60 = 60 // security parameter for ML-DSA-87 + + omega80 = 80 // max# of 1 in the hint for ML-DSA-44 + omega55 = 55 // max# of 1 in the hint for ML-DSA-65 + omega75 = 75 // max# of 1 in the hint for ML-DSA-87 +) + +// ML-DSA-44 parameters. +const ( + k44 = 4 + l44 = 4 + beta44 = eta2 * tau39 + + PublicKeySize44 = 32 + 32*k44*10 + PrivateKeySize44 = 32 + 32 + 64 + 32*((k44+l44)*bitLenOfETA2+d*k44) + + sigEncodedLen44 = lambda128/4 + encodingSize18*l44 + omega80 + k44 +) + +// ML-DSA-65 parameters. +const ( + k65 = 6 + l65 = 5 + beta65 = eta4 * tau49 + + PublicKeySize65 = 32 + 32*k65*10 + PrivateKeySize65 = 32 + 32 + 64 + 32*((k65+l65)*bitLenOfETA4+d*k65) + + sigEncodedLen65 = lambda192/4 + encodingSize20*l65 + omega55 + k65 +) + +// ML-DSA-87 parameters. +const ( + k87 = 8 + l87 = 7 + beta87 = eta2 * tau60 + + PublicKeySize87 = 32 + 32*k87*10 + PrivateKeySize87 = 32 + 32 + 64 + 32*((k87+l87)*bitLenOfETA2+d*k87) + + sigEncodedLen87 = lambda256/4 + encodingSize20*l87 + omega75 + k87 +) + +// A PrivateKey44 is the private key for the ML-DSA-44 signature scheme. +type PrivateKey44 struct { + rho [32]byte // public random seed + k [32]byte // private random seed for signing + tr [64]byte // pre-cached public key Hash, H(pk, 64) + s1 [l44]ringElement // private secret of size L with short coefficients (-4..4) or (-2..2) + s2 [k44]ringElement // private secret of size K with short coefficients (-4..4) or (-2..2) + t0 [k44]ringElement // the Polynomial encoding of the 13 LSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the private key. + a [k44 * l44]nttElement // a is generated and stored in NTT representation +} + +// A Key44 is the key pair for the ML-DSA-44 signature scheme. +type Key44 struct { + PrivateKey44 + xi [32]byte // input seed + t1 [k44]ringElement // the Polynomial encoding of the 10 MSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the public key. +} + +// A PublicKey44 is the public key for the ML-DSA-44 signature scheme. +type PublicKey44 struct { + rho [32]byte + t1 [k44]ringElement + tr [64]byte // H(pk, 64), need to further check if public key requires it + a [k44 * l44]nttElement // a is generated and stored in NTT representation +} + +// PublicKey generates and returns the corresponding public key for the given +// Key44 instance. +func (sk *Key44) PublicKey() *PublicKey44 { + return &PublicKey44{ + rho: sk.rho, + t1: sk.t1, + tr: sk.tr, + a: sk.a, + } +} + +func (pk *PublicKey44) Equal(x crypto.PublicKey) bool { + xx, ok := x.(*PublicKey44) + if !ok { + return false + } + return pk.rho == xx.rho && pk.t1 == xx.t1 +} + +// Bytes converts the PublicKey44 instance into a byte slice. +// See FIPS 204, Algorithm 22, pkEncode() +func (pk *PublicKey44) Bytes() []byte { + // The actual logic is in a separate function to outline this allocation. + b := make([]byte, 0, PublicKeySize44) + return pk.bytes(b) +} + +func (pk *PublicKey44) bytes(b []byte) []byte { + b = append(b, pk.rho[:]...) + for _, f := range pk.t1 { + b = simpleBitPack10Bits(b, f) + } + return b +} + +// Bytes returns the byte representation of the PrivateKey44. +// It copies the internal seed (xi) into a fixed-size byte array +// and returns it as a slice. +func (sk *Key44) Bytes() []byte { + var b [SeedSize]byte + copy(b[:], sk.xi[:]) + return b[:] +} + +// Bytes converts the PrivateKey44 instance into a byte slice. +// See FIPS 204, Algorithm 24, skEncode() +func (sk *PrivateKey44) Bytes() []byte { + b := make([]byte, 0, PrivateKeySize44) + return sk.bytes(b) +} + +func (sk *PrivateKey44) bytes(b []byte) []byte { + b = append(b, sk.rho[:]...) + b = append(b, sk.k[:]...) + b = append(b, sk.tr[:]...) + for _, f := range sk.s1 { + b = bitPackSigned2(b, f) + } + for _, f := range sk.s2 { + b = bitPackSigned2(b, f) + } + for _, f := range sk.t0 { + b = bitPackSigned4096(b, f) + } + return b +} + +func (sk *PrivateKey44) Equal(x any) bool { + xx, ok := x.(*PrivateKey44) + if !ok { + return false + } + return sk.rho == xx.rho && sk.k == xx.k && sk.tr == xx.tr && + sk.s1 == xx.s1 && sk.s2 == xx.s2 && sk.t0 == xx.t0 +} + +// GenerateKey44 generates a new Key44 (ML-DSA-44) using the provided random source. +func GenerateKey44(rand io.Reader) (*Key44, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key44{} + return generateKey44(sk, rand) +} + +func generateKey44(sk *Key44, rand io.Reader) (*Key44, error) { + // Generate a random seed. + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + dsaKeyGen44(sk, &seed) + return sk, nil +} + +// NewKey44 creates a new instance of Key44 using the provided seed. +func NewKey44(seed []byte) (*Key44, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key44{} + return newPrivateKey44FromSeed(sk, seed) +} + +func newPrivateKey44FromSeed(sk *Key44, seed []byte) (*Key44, error) { + if len(seed) != SeedSize { + return nil, errors.New("mldsa: invalid seed length") + } + xi := (*[32]byte)(seed) + dsaKeyGen44(sk, xi) + return sk, nil +} + +func dsaKeyGen44(sk *Key44, xi *[32]byte) { + sk.xi = *xi + H := sha3.NewSHAKE256() + H.Write(xi[:]) + H.Write([]byte{k44}) + H.Write([]byte{l44}) + K := make([]byte, 128) + H.Read(K) + rho, rho1 := K[:32], K[32:96] + K = K[96:] + + sk.rho = [32]byte(rho) + sk.k = [32]byte(K) + + s1 := &sk.s1 + s2 := &sk.s2 + // Algorithm 33, ExpandS + for s := byte(0); s < l44; s++ { + s1[s] = rejBoundedPoly(rho1, eta2, 0, s) + } + for r := byte(0); r < k44; r++ { + s2[r] = rejBoundedPoly(rho1, eta2, 0, r+l44) + } + + // Using rho generate A' = A in NTT form + A := &sk.a + // Algorithm 32, ExpandA + for r := byte(0); r < k44; r++ { + for s := byte(0); s < l44; s++ { + A[r*l44+s] = rejNTTPoly(rho, s, r) + } + } + + // t = NTT_inv(A' * NTT(s1)) + s2 + var s1NTT [l44]nttElement + var nttT [k44]nttElement + for i := range s1 { + s1NTT[i] = ntt(s1[i]) + } + for i := range nttT { + for j := range s1NTT { + nttT[i] = polyAdd(nttT[i], nttMul(s1NTT[j], A[i*l44+j])) + } + } + var t [k44]ringElement + t0 := &sk.t0 + t1 := &sk.t1 + for i := range nttT { + t[i] = polyAdd(inverseNTT(nttT[i]), s2[i]) + // compress t + for j := range n { + t1[i][j], t0[i][j] = power2Round(t[i][j]) + } + } + H.Reset() + ek := sk.PublicKey().Bytes() + H.Write(ek) + H.Read(sk.tr[:]) +} + +// NewPublicKey44 decode an public key from its encoded form. +// See FIPS 204, Algorithm 23 pkDecode() +func NewPublicKey44(b []byte) (*PublicKey44, error) { + // The actual logic is in a separate function to outline this allocation. + pk := &PublicKey44{} + return parsePublicKey44(pk, b) +} + +// See FIPS 204, Algorithm 23 pkDecode() +func parsePublicKey44(pk *PublicKey44, b []byte) (*PublicKey44, error) { + if len(b) != PublicKeySize44 { + return nil, errors.New("mldsa: invalid public key length") + } + + H := sha3.NewSHAKE256() + H.Write(b) + H.Read(pk.tr[:]) + + copy(pk.rho[:], b[:32]) + b = b[32:] + for i := range k44 { + simpleBitUnpack10Bits(b, &pk.t1[i]) + b = b[encodingSize10:] + } + + A := &pk.a + rho := pk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k44; r++ { + for s := byte(0); s < l44; s++ { + A[r*l44+s] = rejNTTPoly(rho, s, r) + } + } + return pk, nil +} + +// NewPrivateKey44 decode an private key from its encoded form. +// See FIPS 204, Algorithm 25 skDecode() +func NewPrivateKey44(b []byte) (*PrivateKey44, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &PrivateKey44{} + return parsePrivateKey44(sk, b) +} + +// See FIPS 204, Algorithm 25 skDecode() +// Decode a private key from its encoded form. +func parsePrivateKey44(sk *PrivateKey44, b []byte) (*PrivateKey44, error) { + if len(b) != PrivateKeySize44 { + return nil, errors.New("mldsa: invalid private key length") + } + copy(sk.rho[:], b[:32]) + copy(sk.k[:], b[32:64]) + copy(sk.tr[:], b[64:128]) + b = b[128:] + for i := range l44 { + f, err := bitUnpackSigned2(b) + if err != nil { + return nil, err + } + sk.s1[i] = f + b = b[encodingSize3:] + } + for i := range k44 { + f, err := bitUnpackSigned2(b) + if err != nil { + return nil, err + } + sk.s2[i] = f + b = b[encodingSize3:] + } + for i := range k44 { + bitUnpackSigned4096(b, &sk.t0[i]) + b = b[encodingSize13:] + } + A := &sk.a + rho := sk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k44; r++ { + for s := byte(0); s < l44; s++ { + A[r*l44+s] = rejNTTPoly(rho, s, r) + } + } + return sk, nil +} + +func (sk *PrivateKey44) Sign(rand io.Reader, message, context []byte) ([]byte, error) { + if len(message) == 0 { + return nil, errors.New("mldsa: empty message") + } + if len(context) > 255 { + return nil, errors.New("mldsa: context too long") + } + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + H := sha3.NewSHAKE256() + H.Write(sk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + if len(context) > 0 { + H.Write(context) + } + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return sk.signInternal(seed[:], mu[:]) +} + +func (sk *PrivateKey44) signInternal(seed, mu []byte) ([]byte, error) { + var s1NTT [l44]nttElement + var s2NTT [k44]nttElement + var t0NTT [k44]nttElement + for i := range s1NTT { + s1NTT[i] = ntt(sk.s1[i]) + } + for i := range s2NTT { + s2NTT[i] = ntt(sk.s2[i]) + } + for i := range t0NTT { + t0NTT[i] = ntt(sk.t0[i]) + } + var rho2 [64 + 2]byte + H := sha3.NewSHAKE256() + H.Write(sk.k[:]) + H.Write(seed[:]) + H.Write(mu[:]) + H.Read(rho2[:64]) + A := &sk.a + + // rejection sampling loop + for kappa := 0; ; kappa = kappa + l44 { + // expand mask + var y [l44]ringElement + for i := range l44 { + index := kappa + i + rho2[64] = byte(index) + rho2[65] = byte(index >> 8) + y[i] = expandMask(rho2[:], gamma1TwoPower17) + } + // compute w and w1 + var w, w1 [k44]ringElement + var wNTT [k44]nttElement + for i := range w { + for j := range y { + wNTT[i] = polyAdd(wNTT[i], nttMul(ntt(y[j]), A[i*l44+j])) + } + w[i] = inverseNTT(wNTT[i]) + // high bits + for j := range w[i] { + w1[i][j] = fieldElement(compressHighBits(w[i][j], gamma2QMinus1Div88)) + } + } + // commitment hash + var cTilde [lambda128 / 4]byte + var w1Encoded [encodingSize6]byte + H.Reset() + H.Write(mu[:]) + for i := range k44 { + simpleBitPack6Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + H.Read(cTilde[:]) + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau39)) + + var cs1 [l44]ringElement + var cs2 [k44]ringElement + var z [l44]ringElement + var r0 [k44][n]int32 + // compute <> and z = <> + y + for i := range l44 { + cs1[i] = inverseNTT(nttMul(cNTT, s1NTT[i])) + z[i] = polyAdd(cs1[i], y[i]) + } + // compute <> and r0 = LowBits(w - <>) + for i := range k44 { + cs2[i] = inverseNTT(nttMul(cNTT, s2NTT[i])) + for j := range cs2[i] { + _, r0[i][j] = decompose(fieldSub(w[i][j], cs2[i][j]), gamma2QMinus1Div88) + } + } + zNorm := vectorInfinityNorm(z[:], 0) + r0Norm := vectorInfinityNormSigned(r0[:], 0) + + // if zNorm >= gamma1 - beta || r0Norm >= gamma2 - beta, then continue + if subtle.ConstantTimeLessOrEq(int(gamma1TwoPower17-beta44), zNorm)|subtle.ConstantTimeLessOrEq(int(gamma2QMinus1Div88-beta44), r0Norm) == 1 { + continue + } + // compute <> + var ct0 [k44]ringElement + for i := range k44 { + ct0[i] = inverseNTT(nttMul(cNTT, t0NTT[i])) + } + // compute infinity norm of <> + ct0Norm := vectorInfinityNorm(ct0[:], 0) + // make hint + var hints [k44]ringElement + vectorMakeHint(ct0[:], cs2[:], w[:], hints[:], gamma2QMinus1Div88) + // if the number of 1 in the hint is greater than omega or the infinity norm of <> >= gamma2, then continue + if (subtle.ConstantTimeLessOrEq(int(omega80+1), vectorCountOnes(hints[:])) | subtle.ConstantTimeLessOrEq(gamma2QMinus1Div88, ct0Norm)) == 1 { + continue + } + // signature encoding + sig := make([]byte, 0, sigEncodedLen44) + sig = append(sig, cTilde[:]...) + for i := range l44 { + sig = bitPackSignedTwoPower17(sig, z[i]) + } + return hintBitPack(sig, hints[:], omega80), nil + } +} + +func (pk *PublicKey44) Verify(sig []byte, message, context []byte) bool { + if len(message) == 0 { + return false + } + if len(context) > 255 { + return false + } + if len(sig) != sigEncodedLen44 { + return false + } + H := sha3.NewSHAKE256() + H.Write(pk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + if len(context) > 0 { + H.Write(context) + } + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return pk.verifyInternal(sig, mu[:]) +} + +func (pk *PublicKey44) verifyInternal(sig, mu []byte) bool { + // Decode the signature + cTilde := sig[:lambda128/4] + sig = sig[lambda128/4:] + var z [l44]ringElement + for i := range l44 { + bitUnpackSignedTwoPower17(sig, &z[i]) + sig = sig[encodingSize18:] + } + zNorm := vectorInfinityNorm(z[:], 0) + var hints [k44]ringElement + if !hintBitUnpack(sig, hints[:], omega80) { + return false + } + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau39)) + + // t = t1 * 2^d + // tNTT = NTT(t)*cNTT + var tNTT [k44]nttElement + t := pk.t1 + for i := range k44 { + for j := range t[i] { + t[i][j] <<= d + } + tNTT[i] = nttMul(ntt(t[i]), cNTT) + } + + var w1, wApprox [k44]ringElement + var zNTT [k44]nttElement + for i := range k44 { + for j := 0; j < l44; j++ { + zNTT[i] = polyAdd(zNTT[i], nttMul(ntt(z[j]), pk.a[i*l44+j])) + } + zNTT[i] = polySub(zNTT[i], tNTT[i]) + wApprox[i] = inverseNTT(zNTT[i]) + } + + H := sha3.NewSHAKE256() + H.Write(mu[:]) + var w1Encoded [encodingSize6]byte + for i := range k44 { + for j := range wApprox[i] { + w1[i][j] = useHint(hints[i][j], wApprox[i][j], gamma2QMinus1Div88) + } + simpleBitPack6Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + var cTilde1 [lambda128 / 4]byte + H.Read(cTilde1[:]) + return subtle.ConstantTimeLessOrEq(int(gamma1TwoPower17-beta44), zNorm) == 0 && + subtle.ConstantTimeCompare(cTilde[:], cTilde1[:]) == 1 +} diff --git a/mldsa/mldsa44_test.go b/mldsa/mldsa44_test.go new file mode 100644 index 0000000..8025b94 --- /dev/null +++ b/mldsa/mldsa44_test.go @@ -0,0 +1,190 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "bytes" + "encoding/hex" + "testing" +) + +// https://github.com/usnistgov/ACVP-Server/blob/master/gen-val/json-files/ML-DSA-keyGen-FIPS204/internalProjection.json +var kenGen44InternalProjectionCases = []struct { + seed string + pk string + sk string +}{ + {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}, + {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}, + {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}, +} + +func TestKeyGen44(t *testing.T) { + for _, c := range kenGen44InternalProjectionCases { + xi, _ := hex.DecodeString(c.seed) + pk, _ := hex.DecodeString(c.pk) + sk, _ := hex.DecodeString(c.sk) + priv, err := NewKey44(xi) + if err != nil { + t.Fatalf("NewPrivateKey44 failed: %v", err) + } + pub := priv.PublicKey() + pubBytes := pub.Bytes() + if !bytes.Equal(pubBytes, pk) { + t.Errorf("Public key mismatch: got %x, want %x", pubBytes, pk) + } + pub2, err := NewPublicKey44(pubBytes) + if err != nil { + t.Fatalf("faile to parse public key: %v", err) + } + if !pub.Equal(pub2) { + t.Errorf("Public key not equal: got %x, want %x", pubBytes, pub2.Bytes()) + } + privBytes := priv.PrivateKey44.Bytes() + if !bytes.Equal(privBytes, sk) { + t.Errorf("Private key mismatch: got %x, want %x", privBytes, sk) + } + + priv2, err := NewPrivateKey44(privBytes) + if err != nil { + t.Fatalf("failed to parse private key: %v", err) + } + if !priv.Equal(priv2) { + t.Errorf("Private key not equal: got %x, want %x", privBytes, priv2.Bytes()) + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigGen-FIPS204/internalProjection.json +var sigGen44InternalProjectionCases = []struct { + mu string + pk string + sk string + sig string +}{ + {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}, + {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}, + {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}, + {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}, + {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}, +} + +func TestSign44(t *testing.T) { + var seed [32]byte + for _, c := range sigGen44InternalProjectionCases { + sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + mu, _ := hex.DecodeString(c.mu) + priv, err := NewPrivateKey44(sk) + if err != nil { + t.Fatalf("NewPrivateKey44 failed: %v", err) + } + sig2, err := priv.signInternal(seed[:], mu) + if err != nil { + t.Fatalf("failed to sign: %v", err) + } + if !bytes.Equal(sig2[:32], sig[:32]) { + t.Errorf("signature mismatch(signer's commitment hash): got %x, want %x", sig2[:32], sig[:32]) + } + if !bytes.Equal(sig2[32:32+encodingSize18*l44], sig[32:32+encodingSize18*l44]) { + t.Errorf("signature mismatch(signer's response): got %x, want %x", sig2[32:32+encodingSize18*l44], sig[32:32+encodingSize18*l44]) + } + if !bytes.Equal(sig2[lambda128/4+encodingSize18*l44:], sig[lambda128/4+encodingSize18*l44:]) { + t.Errorf("signature mismatch(hint): got %x, want %x", sig2[lambda128/4+encodingSize18*l44:], sig[lambda128/4+encodingSize18*l44:]) + } + pub, err := NewPublicKey44(pk) + if err != nil { + t.Fatalf("NewPublicKey44 failed: %v", err) + } + if !pub.verifyInternal(sig, mu) { + t.Error("signature verification failed") + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigVer-FIPS204/internalProjection.json +var sigVer44InternalProjectionCases = []struct { + pk string + sk string + message string + context string + sig string + passed bool +}{ + {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true, + }, + {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false, + }, +} + +func TestVerify44(t *testing.T) { + for _, c := range sigVer44InternalProjectionCases { + //sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + msg, _ := hex.DecodeString(c.message) + ctx, _ := hex.DecodeString(c.context) + + pub, err := NewPublicKey44(pk) + if err != nil { + t.Fatalf("NewPublicKey44 failed: %v", err) + } + if pub.Verify(sig, msg, ctx) != c.passed { + t.Errorf("Verify failed") + } + } +} diff --git a/mldsa/mldsa65.go b/mldsa/mldsa65.go new file mode 100644 index 0000000..3c83411 --- /dev/null +++ b/mldsa/mldsa65.go @@ -0,0 +1,498 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "crypto" + "crypto/sha3" + "crypto/subtle" + "errors" + "io" +) + +// A PrivateKey65 is the private key for the ML-DSA-65 signature scheme. +type PrivateKey65 struct { + rho [32]byte // public random seed + k [32]byte // private random seed for signing + tr [64]byte // pre-cached public key Hash, H(pk, 64) + s1 [l65]ringElement // private secret of size L with short coefficients (-4..4) or (-2..2) + s2 [k65]ringElement // private secret of size K with short coefficients (-4..4) or (-2..2) + t0 [k65]ringElement // the Polynomial encoding of the 13 LSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the private key. + a [k65 * l65]nttElement // a is generated and stored in NTT representation +} + +// A Key65 is the key pair for the ML-DSA-65 signature scheme. +type Key65 struct { + PrivateKey65 + xi [32]byte // input seed + t1 [k65]ringElement // the Polynomial encoding of the 10 MSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the public key. +} + +// A PublicKey65 is the public key for the ML-DSA-65 signature scheme. +type PublicKey65 struct { + rho [32]byte + t1 [k65]ringElement + tr [64]byte // H(pk, 64), need to further check if public key requires it + a [k65 * l65]nttElement // a is generated and stored in NTT representation +} + +// PublicKey generates and returns the corresponding public key for the given +// Key65 instance. +func (sk *Key65) PublicKey() *PublicKey65 { + return &PublicKey65{ + rho: sk.rho, + t1: sk.t1, + tr: sk.tr, + a: sk.a, + } +} + +func (pk *PublicKey65) Equal(x crypto.PublicKey) bool { + xx, ok := x.(*PublicKey65) + if !ok { + return false + } + return pk.rho == xx.rho && pk.t1 == xx.t1 +} + +// Bytes converts the PublicKey65 instance into a byte slice. +// See FIPS 204, Algorithm 22, pkEncode() +func (pk *PublicKey65) Bytes() []byte { + // The actual logic is in a separate function to outline this allocation. + b := make([]byte, 0, PublicKeySize65) + return pk.bytes(b) +} + +func (pk *PublicKey65) bytes(b []byte) []byte { + b = append(b, pk.rho[:]...) + for _, f := range pk.t1 { + b = simpleBitPack10Bits(b, f) + } + return b +} + +// Bytes returns the byte representation of the PrivateKey65. +// It copies the internal seed (xi) into a fixed-size byte array +// and returns it as a slice. +func (sk *Key65) Bytes() []byte { + var b [SeedSize]byte + copy(b[:], sk.xi[:]) + return b[:] +} + +// Bytes converts the PrivateKey65 instance into a byte slice. +// See FIPS 204, Algorithm 24, skEncode() +func (sk *PrivateKey65) Bytes() []byte { + b := make([]byte, 0, PrivateKeySize65) + return sk.bytes(b) +} + +func (sk *PrivateKey65) bytes(b []byte) []byte { + b = append(b, sk.rho[:]...) + b = append(b, sk.k[:]...) + b = append(b, sk.tr[:]...) + for _, f := range sk.s1 { + b = bitPackSigned4(b, f) + } + for _, f := range sk.s2 { + b = bitPackSigned4(b, f) + } + for _, f := range sk.t0 { + b = bitPackSigned4096(b, f) + } + return b +} + +func (sk *PrivateKey65) Equal(x any) bool { + xx, ok := x.(*PrivateKey65) + if !ok { + return false + } + return sk.rho == xx.rho && sk.k == xx.k && sk.tr == xx.tr && + sk.s1 == xx.s1 && sk.s2 == xx.s2 && sk.t0 == xx.t0 +} + +// GenerateKey65 generates a new Key65 (ML-DSA-65) using the provided random source. +func GenerateKey65(rand io.Reader) (*Key65, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key65{} + return generateKey65(sk, rand) +} + +func generateKey65(sk *Key65, rand io.Reader) (*Key65, error) { + // Generate a random seed. + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + dsaKeyGen65(sk, &seed) + return sk, nil +} + +// NewKey65 creates a new instance of Key65 using the provided seed. +func NewKey65(seed []byte) (*Key65, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key65{} + return newPrivateKey65FromSeed(sk, seed) +} + +func newPrivateKey65FromSeed(sk *Key65, seed []byte) (*Key65, error) { + if len(seed) != SeedSize { + return nil, errors.New("mldsa: invalid seed length") + } + xi := (*[32]byte)(seed) + dsaKeyGen65(sk, xi) + return sk, nil +} + +func dsaKeyGen65(sk *Key65, xi *[32]byte) { + sk.xi = *xi + H := sha3.NewSHAKE256() + H.Write(xi[:]) + H.Write([]byte{k65}) + H.Write([]byte{l65}) + K := make([]byte, 128) + H.Read(K) + rho, rho1 := K[:32], K[32:96] + K = K[96:] + + sk.rho = [32]byte(rho) + sk.k = [32]byte(K) + + s1 := &sk.s1 + s2 := &sk.s2 + // Algorithm 33, ExpandS + for s := byte(0); s < l65; s++ { + s1[s] = rejBoundedPoly(rho1, eta4, 0, s) + } + for r := byte(0); r < k65; r++ { + s2[r] = rejBoundedPoly(rho1, eta4, 0, r+l65) + } + + // Using rho generate A' = A in NTT form + A := &sk.a + // Algorithm 32, ExpandA + for r := byte(0); r < k65; r++ { + for s := byte(0); s < l65; s++ { + A[r*l65+s] = rejNTTPoly(rho, s, r) + } + } + + // t = NTT_inv(A' * NTT(s1)) + s2 + var s1NTT [l65]nttElement + var nttT [k65]nttElement + for i := range s1 { + s1NTT[i] = ntt(s1[i]) + } + for i := range nttT { + for j := range s1NTT { + nttT[i] = polyAdd(nttT[i], nttMul(s1NTT[j], A[i*l65+j])) + } + } + var t [k65]ringElement + t0 := &sk.t0 + t1 := &sk.t1 + for i := range nttT { + t[i] = polyAdd(inverseNTT(nttT[i]), s2[i]) + // compress t + for j := range n { + t1[i][j], t0[i][j] = power2Round(t[i][j]) + } + } + H.Reset() + ek := sk.PublicKey().Bytes() + H.Write(ek) + H.Read(sk.tr[:]) +} + +// NewPublicKey65 decode an public key from its encoded form. +// See FIPS 204, Algorithm 23 pkDecode() +func NewPublicKey65(b []byte) (*PublicKey65, error) { + // The actual logic is in a separate function to outline this allocation. + pk := &PublicKey65{} + return parsePublicKey65(pk, b) +} + +// See FIPS 204, Algorithm 23 pkDecode() +func parsePublicKey65(pk *PublicKey65, b []byte) (*PublicKey65, error) { + if len(b) != PublicKeySize65 { + return nil, errors.New("mldsa: invalid public key length") + } + + H := sha3.NewSHAKE256() + H.Write(b) + H.Read(pk.tr[:]) + + copy(pk.rho[:], b[:32]) + b = b[32:] + for i := range k65 { + simpleBitUnpack10Bits(b, &pk.t1[i]) + b = b[encodingSize10:] + } + + A := &pk.a + rho := pk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k65; r++ { + for s := byte(0); s < l65; s++ { + A[r*l65+s] = rejNTTPoly(rho, s, r) + } + } + return pk, nil +} + +// NewPrivateKey65 decode an private key from its encoded form. +// See FIPS 204, Algorithm 25 skDecode() +func NewPrivateKey65(b []byte) (*PrivateKey65, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &PrivateKey65{} + return parsePrivateKey65(sk, b) +} + +// See FIPS 204, Algorithm 25 skDecode() +// Decode a private key from its encoded form. +func parsePrivateKey65(sk *PrivateKey65, b []byte) (*PrivateKey65, error) { + if len(b) != PrivateKeySize65 { + return nil, errors.New("mldsa: invalid private key length") + } + copy(sk.rho[:], b[:32]) + copy(sk.k[:], b[32:64]) + copy(sk.tr[:], b[64:128]) + b = b[128:] + for i := range l65 { + f, err := bitUnpackSigned4(b) + if err != nil { + return nil, err + } + sk.s1[i] = f + b = b[encodingSize4:] + } + for i := range k65 { + f, err := bitUnpackSigned4(b) + if err != nil { + return nil, err + } + sk.s2[i] = f + b = b[encodingSize4:] + } + for i := range k65 { + bitUnpackSigned4096(b, &sk.t0[i]) + b = b[encodingSize13:] + } + A := &sk.a + rho := sk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k65; r++ { + for s := byte(0); s < l65; s++ { + A[r*l65+s] = rejNTTPoly(rho, s, r) + } + } + return sk, nil +} + +func (sk *PrivateKey65) Sign(rand io.Reader, message, context []byte) ([]byte, error) { + if len(message) == 0 { + return nil, errors.New("mldsa: empty message") + } + if len(context) > 255 { + return nil, errors.New("mldsa: context too long") + } + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + H := sha3.NewSHAKE256() + H.Write(sk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + if len(context) > 0 { + H.Write(context) + } + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return sk.signInternal(seed[:], mu[:]) +} + +func (sk *PrivateKey65) signInternal(seed, mu []byte) ([]byte, error) { + var s1NTT [l65]nttElement + var s2NTT [k65]nttElement + var t0NTT [k65]nttElement + for i := range s1NTT { + s1NTT[i] = ntt(sk.s1[i]) + } + for i := range s2NTT { + s2NTT[i] = ntt(sk.s2[i]) + } + for i := range t0NTT { + t0NTT[i] = ntt(sk.t0[i]) + } + var rho2 [64 + 2]byte + H := sha3.NewSHAKE256() + H.Write(sk.k[:]) + H.Write(seed[:]) + H.Write(mu[:]) + H.Read(rho2[:64]) + A := &sk.a + + // rejection sampling loop + for kappa := 0; ; kappa = kappa + l65 { + // expand mask + var y [l65]ringElement + for i := range l65 { + index := kappa + i + rho2[64] = byte(index) + rho2[65] = byte(index >> 8) + y[i] = expandMask(rho2[:], gamma1TwoPower19) + } + // compute w and w1 + var w, w1 [k65]ringElement + var wNTT [k65]nttElement + for i := range w { + for j := range y { + wNTT[i] = polyAdd(wNTT[i], nttMul(ntt(y[j]), A[i*l65+j])) + } + w[i] = inverseNTT(wNTT[i]) + // high bits + for j := range w[i] { + w1[i][j] = fieldElement(compressHighBits(w[i][j], gamma2QMinus1Div32)) + } + } + // commitment hash + var cTilde [lambda192 / 4]byte + var w1Encoded [encodingSize4]byte + H.Reset() + H.Write(mu[:]) + for i := range k65 { + simpleBitPack4Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + H.Read(cTilde[:]) + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau49)) + + var cs1 [l65]ringElement + var cs2 [k65]ringElement + var z [l65]ringElement + var r0 [k65][n]int32 + // compute <> and z = <> + y + for i := range l65 { + cs1[i] = inverseNTT(nttMul(cNTT, s1NTT[i])) + z[i] = polyAdd(cs1[i], y[i]) + } + // compute <> and r0 = LowBits(w - <>) + for i := range k65 { + cs2[i] = inverseNTT(nttMul(cNTT, s2NTT[i])) + for j := range cs2[i] { + _, r0[i][j] = decompose(fieldSub(w[i][j], cs2[i][j]), gamma2QMinus1Div32) + } + } + zNorm := vectorInfinityNorm(z[:], 0) + r0Norm := vectorInfinityNormSigned(r0[:], 0) + + // if zNorm >= gamma1 - beta || r0Norm >= gamma2 - beta, then continue + if subtle.ConstantTimeLessOrEq(int(gamma1TwoPower19-beta65), zNorm)|subtle.ConstantTimeLessOrEq(int(gamma2QMinus1Div32-beta65), r0Norm) == 1 { + continue + } + // compute <> + var ct0 [k65]ringElement + for i := range k65 { + ct0[i] = inverseNTT(nttMul(cNTT, t0NTT[i])) + } + // compute infinity norm of <> + ct0Norm := vectorInfinityNorm(ct0[:], 0) + // make hint + var hints [k65]ringElement + vectorMakeHint(ct0[:], cs2[:], w[:], hints[:], gamma2QMinus1Div32) + // if the number of 1 in the hint is greater than omega or the infinity norm of <> >= gamma2, then continue + if (subtle.ConstantTimeLessOrEq(int(omega55+1), vectorCountOnes(hints[:])) | subtle.ConstantTimeLessOrEq(gamma2QMinus1Div32, ct0Norm)) == 1 { + continue + } + // signature encoding + sig := make([]byte, 0, sigEncodedLen65) + sig = append(sig, cTilde[:]...) + for i := range l65 { + sig = bitPackSignedTwoPower19(sig, z[i]) + } + return hintBitPack(sig, hints[:], omega55), nil + } +} + +func (pk *PublicKey65) Verify(sig []byte, message, context []byte) bool { + if len(message) == 0 { + return false + } + if len(context) > 255 { + return false + } + if len(sig) != sigEncodedLen65 { + return false + } + H := sha3.NewSHAKE256() + H.Write(pk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + H.Write(context) + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return pk.verifyInternal(sig, mu[:]) +} + +func (pk *PublicKey65) verifyInternal(sig, mu []byte) bool { + // Decode the signature + cTilde := sig[:lambda192/4] + sig = sig[lambda192/4:] + var z [l65]ringElement + for i := range l65 { + bitUnpackSignedTwoPower19(sig, &z[i]) + sig = sig[encodingSize20:] + } + zNorm := vectorInfinityNorm(z[:], 0) + var hints [k65]ringElement + if !hintBitUnpack(sig, hints[:], omega55) { + return false + } + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau49)) + + // t = t1 * 2^d + // tNTT = NTT(t)*cNTT + var tNTT [k65]nttElement + t := pk.t1 + for i := range k65 { + for j := range t[i] { + t[i][j] <<= d + } + tNTT[i] = nttMul(ntt(t[i]), cNTT) + } + + var w1, wApprox [k65]ringElement + var zNTT [k65]nttElement + for i := range k65 { + for j := 0; j < l65; j++ { + zNTT[i] = polyAdd(zNTT[i], nttMul(ntt(z[j]), pk.a[i*l65+j])) + } + zNTT[i] = polySub(zNTT[i], tNTT[i]) + wApprox[i] = inverseNTT(zNTT[i]) + } + + H := sha3.NewSHAKE256() + H.Write(mu[:]) + var w1Encoded [encodingSize4]byte + for i := range k65 { + for j := range wApprox[i] { + w1[i][j] = useHint(hints[i][j], wApprox[i][j], gamma2QMinus1Div32) + } + simpleBitPack4Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + var cTilde1 [lambda192 / 4]byte + H.Read(cTilde1[:]) + return subtle.ConstantTimeLessOrEq(int(gamma1TwoPower19-beta65), zNorm) == 0 && + subtle.ConstantTimeCompare(cTilde[:], cTilde1[:]) == 1 +} diff --git a/mldsa/mldsa65_test.go b/mldsa/mldsa65_test.go new file mode 100644 index 0000000..54bad3e --- /dev/null +++ b/mldsa/mldsa65_test.go @@ -0,0 +1,190 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "bytes" + "encoding/hex" + "testing" +) + +// https://github.com/usnistgov/ACVP-Server/blob/master/gen-val/json-files/ML-DSA-keyGen-FIPS204/internalProjection.json +var kenGen65InternalProjectionCases = []struct { + seed string + pk string + sk string +}{ + {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}, + {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}, + { + "6DC10A11C8D14EAF3C4665F31828CFC4B8584D6C1A7712F1D4E4E62EDD3E9440", + "5DA10AF1894B5A37BA2EE3147B1A493609D80DA048FE3D68A282E87E2DBBF002E8690207C3A44461B4C9509EE57DA94F7DD7A9E148B5E2B61CFF49B067102DE588563FB737419C9548D7E4EC40AA8824F4F3FA50285CA18A923ACA1265B6F36B214CD471704299E7387A4A7FE2888D9E1EC3B73A433F6D12A5C68918D341E6EBA78B3C965DF8EB30618FB6BABF0E0EF3820C4F9C874FCB7BE66603B327D7F2CA39EC1FBECB2F08B73EB1C2316835E2152957BCEDE2DD63917114F520F917818535A4DE5197151FBC2DB616DBBE72DD460279393BD76CFCD860E8975980F9FAA11B9D5730879F22AFDF6227A3548251A3F96A95B1DBF2AF6AD457880CD8F5493866CA1C7B22F6B4CA77CB433B5280EE96EA0A2D083DBD50AC23ACB2A4FAE71FC1633D12B2F3CF99841A61317F4601AA7540C7F8402E2F45F5CE4DF67C83A088DE4A470A2C59FBCAE87516E4C1669D482FD965A42404B85AC8CBC88C0731C1BAE816DC9F04FD9547707A0C4D63CBAF79DE9153704B80D34FF9AEE2C9D9127A128471E2CDD1A16C7FDA41244F9D02678ACBA38561A102179F6820F28100BE679008874B7AAA2974F4941436B78F6E7DBBEDDDDA6FB3D8EEAE6B94F1E2C4A4349E049D0E14C1355DA82F86ADDB72B0658290D46EBB606D3CF212AC4B0F584E73E03EDFD74A98632660A796A28E8B9C41CF0CAC7014D0D816B2B649A5273FAD7C8CD93D8E4462FE19A478F1F5F569DC90D5E155C52732B88C590595F5EB121F20CD97D2ADC6B7EFDDC2DFF0BDD8A65DBA31E90000D644E13BA026B8F3406A87BB376A9B1C43B67F4BD2A41D3FBB474902EA2199AAA72B567FCFE1880622BD87888DF87C7FD52CED43FB2E39BA497AD8795AAA95416B06A2AAD17BAC6BAED6BA75B64A991DD4DFD1C5BC8FCA8B2F54178422FA5A6DA86F4B2AD82A5BD29B640EF75611B69D26DE923345DA31C469960E42A19A5E743E9A24EF62A06309AB176FBEC5430D7B1D11340A49251223488B8CD0CD5B6410110D733F4CEB5001FE1D58050980FABFFA6BE15A912AE336B6BFBC98E667A75D83FAB9D0EAFD70855B63B364DE94C0008775E760DD6659A4DFF80696CDEEAE176AC1F36B2883B04849152A366AC71E19ADE3FDA1FA363FC6597D6C9CBCDD9ACE3E077E1BDEA9656FA55CC4016CE23FDC11A9724FC056892EE112BF06397FAB6A9AD9846CC849D67495DFB34B78BA6CB309F12D968AD1204B47BF9420657815264CBC5CF2E492CD74E73EEF8746423F76C4F504F40E74C64FE4E20356DC166248BE46058F8E1ADBC7870B65337BA5DD3F9D06D897EBC7DD1EE4F89F5A12BC69485B5673610C5A70E22AEF2EA2F2C225CA9D2657EBC73EBCD779C0A54E45125199321E24E7DDF56F72633E7FC6489A4E1D9A3393826E933CFD3E217A592798C2D1E515652371A79038F77349BE97580EF9E7779A0CF5DFFF7E8B8F6D0E65B9E3F4C25BCC2DD3AE8B7CE8BBCC8D2CE6489BA0C76462E5D30FEAE7E25D7B19BCDE116C6E2BAAE8DE3BFB724FD23DFF7550DD4635B237117205DC0D25931DC46182BFE777B9C13F054AA5E8FA5CCB6BE1B8A87B5D8436FB620EB380C6687D680982150E9489ED15486190A2832A7EB813330F93FC54CECB0790FA7C5ED54FD68EF7A14F44B9C7D0AC727FC207ACF7B0D88AB4049E0502204BCC747D31C80862CF8E574ABD04E9ECD76F1466C581B4A4FE084FC58F2A309858A08B4C5BDEF00E9339160858D45BB4743BFB1E4D74D4F0A0CF6384B09294E854D516F8E4DB5CEE8A76BBD344CD30B0941B980F964150D26CB7D92B6C697FE1F08BB91B799473813B67B23CE203DF6F93A65FB27F44A6E606D882DBCA909782818248DAC880E3ECF838FC3C67A0A7D839E4BF476EEBC0827D6596721CDE3B397F98F3C7470B131E2F9F83B3899A09B121E9470F336EFD87561A8BEAD82B93D8C4B008D4D954849EC5F9B072AB710F24E0147D3DD3472B5EBC6577FEB939091FBFFE51A083FCECEA84422EFF6163CCABDE18FB473DB941484B1084B4746D3769FF63F40B7202DA8A9D25D19F4E274C4CF239D2FACE07154872D71D832C29769FB2B9ED3AEC529E9FB9D85075569473549912303CAB6FAD884579416BAEC4EF2D91AE54E64798432428A47BA4AC7D19CB836AE3AD323F55140BBB3C6ACB8037601479E867772A3C760E36F88CD18751A708148BD6311F3BC4BC234BB0C6F7FA8FC5A61E683819C4CF2F7F4F64A8A7A24B4EE1D634321D28548F2D7F6A02EE690244B73DF3B4FF78D77B8F36984A695AFDC63683D245DC571D9171A24EE7B1866305EEB16FFBBE96D9B1AE524E53967C0C4C9986D116098C67ED6CFF8A965805AD34EB21E008F7A68EEFCFBAB76FB597781A35DB87AC499A4BD13CD908049BDC151646A82B04390A3D46EE6F6C15340471F0B58DE573B7B15E0A112766684370FEF61C2D455810C8CA0A7B6559C0B8DF1301AA673F87FD7BDDA483C948909F6E3D84EA415F618C6B241445A903F9FCA8F6A8F38101112E223D4AD884FC131F6EA3ECBCB93FCFDD62207A161DBF2208D06964E6C7E90E9EFCCC4E0B92F3D4C425D90EE91E02461F5ABCA59C4C87607D9A4BC9F954D7B0B7A63D4CE995119FA8F17D7B94510CC1941877182D466CB48E325698A7E566494AE73FEDB814B72916FA73ABDEF796F298168B50ED53AB0C519748A375C38013EAB8341494BE066B1A8421DFE8C4ABB1E51C2F6DB020A1EF617C4508EDB09F3CEFA759B6", + "5DA10AF1894B5A37BA2EE3147B1A493609D80DA048FE3D68A282E87E2DBBF002FE3710473809261B0D2FB336E591534716812B1B9FBB19D29C3AADD977DFFBD44B4E6A0C5E28ACFB7A1BC87D45E54C3D5E7093B8E22DE3DC0DE854D597FF92C5C64A84700FEC97BC67FBFAFBF2B9D9B2C0F25E44918F3E15AEAA9B522934BF4418236482823621814371331223250658815510310087125572464841167615162082753714801855761535313380125462627318441336674213487441552587487427527024510314287075088314243370781578780401535055660616022584316458820641618354407187125144132520740781777883620665153364334457563474565833488077828841152367801678303887875611822765846461256670054450385004884222723814530435244613121826147656481602345676006826618687783708626713836445402570268638775427056086767212800417581212530300828122350784318460501573182556456370841458770612202218064047205630614041705054306400003863380447241787660756425070443142537834171233343821723266361325526170842642566522513132387708581224101263875060246678825338521483487786411515124164440526835064280664054316686545445521421052713502674267582500757725478542521864044768566371455458817706774207665020657432664000116878725054534880845807086703755544828318538660833550731528287520782827735560013300725485178554873635501724224101375844855787607720654774776306036621043224324673573366867876304324731708012538483578248883251544368721860217141775332001448062716084518330732885105086007772317087481063818763012010303851434100157602281723000444647258756207273105862748321357618214831018874600258625774787720565522447782836702508350580680157212381000848738746582510566817777176514556885316561828127514763188843147666220188346544677605030415733802734803327538453660484675610258850270521263073551376504250610460645150077704825512581020545143402663153641304072278482684708748141271518657741823564114656530651480372608724513884161483788815088750507745073473250154421333247006015354175580361633640052112541578827483605687033231415282183540366657686618330661714602637677060143604144374154087243587665338121583781728275066624831082476886051822488853307554128854007545738503088658336830746558665152605512140352725233328060256625012711566622841812262512021241447230247786700131125707641264717611263444221085714573170524021358422162653630534630385863625770706474860434646432500246355585868666102047625231421076264847523826252112677336054741363546142608276333437378250583488700618214837888557316086858601572351702378330720731080476728554865012711853342612253136820630048166466538135413822018153834880724601414388868623658327243375633783464603502615660350143173373764280801225120021520314536225046326154527385430704063067065274027434038366005212226523175224411563063437775143045338727737445172511383516688118714555121652625847447840415666888851741554086013477822443458158538412407156247355270133408318583511655847784477842358706560504324584134366053028142173174131035141733137555777014116187341871735681415302435321340878433224562581607506056454744180531205174347248151647202053603484855264318877458545403530782031645156308605367125754064428148765360768118615330511384416464824381202426430643624034334157670436630462027317080955C5E74320CFB6E5C412C28A060FA33D75D431BF37FB53B7CB497441EB11CA50ADFA0A97A5F549D717D1C56C93282C203104A982122D63C578DCF939B4C58AF699BEE16844C715E0130A0911F750459704A65E777A7A17BBC7EAFD6197073F5ECA869E0E7C5279BB9735D01C2EDCD39FCFF40E4A99DE1960BE7A4E25EAD9818FF48462C3072814A93E3ED098383CF018508CB14FBCE5C0FDCED1E40AF714D78A63B6660B415DA16FC04C00B289457469F9AA73790AC0B93C8EC3D86E4C5189EDC0E12360EE3BD126244EB844BD2E29467FDB2063C856D34019BAB1A63D00927D84757D1E657793520468280D70B8A9AA14A2E9FBFED4744783751B6E007183534AEA8A9BA59285E10839E90D4F5FDE02542471CF460E0FB1EF45B4D45FAA11221C742D97389978889EDC3BDFEEA654D51ED14E9D0D2AAEB00EEBE08E2B956E8E453FE4B211518E2AC23CB93C361CE4E58AABB87F5E99E33B258614FC0AA17DE70F53AD49461657670563CE05839BADA734DA445A95F51E7D78B2DCB8B7A620420BA390192A59E179A4367E986B7474DE0F005CC1AC6C48F840210466B59E95945D4ED7A28567218EDF8F5778325AF98EC040551577B4772A68CF9A25987C3359D8883BBA98DA725797747809E24C3DC2BC02AD794342AA6B8E39CD37C9069C5E87306A7F4C3EF8670A9A12DECCF347F48CEE2F81BA3EF69C9052B9EC1B28CC4B6989EF2C9AD1478233CF9A625136EE99E0F31CC00E59E60DDE0DABC811AF34475920A7EDF9DBD0B7F1FAE695168EC30196FCA35E9E64FB35234AA229B5F547272A1EF1FC3F67648BB756DA2718824FEB4F55884DCF0FB1CACAE4FA2C78CE480130BB223EABB2838DCB851F92F6012A07DA2EB4CF733DD75D6793FE6822631EF64E640EBDE8D8B2FC5ECFD662A16B9AFFA0A9EE4FC65D69F339D4D60C0ACD1F723B5FEA780EC083E228E68020B4AFEAC584C3F3DC1C5E474AE31B3EB1BA2FDFCF05D66B26E2986477D61C97B79806A2B5179603C8D40923C853C5D39598861EE3C99BFD62489777A309CBCEAC288742D46CF35B4A40781EF89612927ADCBFD5606B0ADF1AE5CCE1ABB1F7B2DAA6DD6D884CB774FC7DA25EF2E3D2C22042FC46B7110373B325161C44BED020ACF18D070E6BE9E5CD371C2E0801B8233C4CEE9C58C7C4B689C1F9EF8FF371842DD4DE39579A34694BA9A8E1B30629AD1646B4B26820E83734B1DBEB3D070953052C382BB99FF788A146FDC94E045BF7E33F5B7BE52466A2A2F2B7B835B0959D88557B4E4612435AC185A09342BA27AE0E33B945921511206995AE3113CC937627F2B99C58EC0EC0080E7330041CA2B9C869E223CB88E35C490E6B4C209CDE11A9BD273579D913C93D13BA2E1B6B1066A601251767CA638904CA635C79C8A545D4AF436982AD65A0094489D4AEA78014BE0BC964A9CC8834E95289E201EA67F7FD3CAB1DF434314224F34CE900F9D4806629614E704BDDB8CE5C2DD53E7182630FFF373541217BD9669CB5F657A49AC77D8C4C8C1D939E92B778BEFA6B0B2E6E06036A1B0FB31807FD631A1AA743EC0678BC3F504886E2095F282C80E8EC93A9912FDB483826D299C2A61F5C7D606AB218A8644183CB63317AAF405ABC2FC5B4FE610D0CBA8E3295A9ED6652FBBAB2EC39344FE0000281DB93E5FA878DD279055820CEF4952C2E674315F031AC562264D7EF7597850627B083EF9898D0C8B01D62C0D489EA5C5EF9E219E72A323A2E4ED29C903D76F0475AD7126ED0B831571CA8D4922A91DEFBDB9F498A9F7B9297557510327D2CEC6254836F94AC882516EBB697AEADE0C01D52B33ED966A7A86C13663A5728716E83ECCBD1CA69487EDB1D4473335BBB32C0ABC7351C1ACD426DC7C306A0B38A74F43324512011BC0507FE3D6E13A1477DAD0C6F7F4EB1C29CE4B0E45227BC9596B4C438E3DBDA11D698F6764AC1B3694B9256C55A00D62BCE67E5B822B6CD9D425517A62C9FBB9E7A2497BE1EEA0F09981158272FFD2018C55000E55A29E33AF6FA575BA33936DD75BC5059C8009A04A82669CEE0C7E440E7886E80EFA3D7E24E814540456A9641320DB9DC560360F9E306E16CEE7092996D2CAD78C5707B660B797ABB8233664F2129A03F870EE374A379C6ED8DF213524C51DFE077C7833B598170DBAAF23EB837D9740466014F990E6574FD6BA5647C95BBFF5B70D18B9AC1D1F8C0C1339D18F07A2EEC68A40B8ADB2AC6AACED1F46D4C49AC881CDAD2233B9477C37750C0DF19396FBF7A1E5AD416C39D0B46764B20856F087CD9D3F20BAF33382ECE1D5F4CB1690EEB48531E316C409C7F964109384EA317B1FD7E9332510720E93BCC25F5C9CC6FDA2BFDB9541C32CD0D4AC1542EDC17083B4203FD17D8C668031C8FF0369BC66B92537A7C7BF8C0A6CF24A69FD1E4073B29A88EAEBDE487144698F719961B93B9C387EE70E65752ECDC58148779E6E8CAC886B70C9BFC65CAEB376949CA8314A296CE33FF6675DA86E1C89D3D9392D700F32B1E3574205CDDD3F3CF87A106918A4C0CC235E7E7F8C3CBD93540745DE971C5CE0DBB68D250CD097AF093A1D24BB99D1AA8B7EE51BB7BBBA0B65CECA8083F0AFC5E192BBD63A1FEAED54B63E17F122DA226F3B187F3F26E02134A569ACF1D3A06F2D4EC954C4A5345FA08901900DC52106A94E3F7768A76E5829A2371961FA6C3D6A48924E98FF334A759843AE8942DAF608609D8B15FE6A38AFE4AC1DAF16CCF926456052CF794984743858F0A5270D4A7BCC0ACDF548790F2CAC9DFEB807086AA76BDD432636C11ECDE6C12A151F1F4A9243CE6C2FD6017E6359CBA6409A2423BDAB1D98FA3D44A71F33FFFD5DE66B7444F50655B1CF8CE9521793FC6AE735C2E611AD87F2B4F1FD8638EB2F9288631511D4E272261572B771792856B0CF1D3DADACBB55C8BE8E7C3A0B6837FBCFFA2681C4299B046F332D27CC8BE28400751CD9E8AC64ED9CE27553C67EABAEB2E02AFED1CD470D5CD9629CBA1658E630C7B98B1248C8078495C663207DF650A9097CAC9D69C337CB220F7D6685E5CDFB22B631055ACBE0A9AF41AB17B7D75069CEE67667F4054365A2337A3ACC5D02236B9325C3874DD4D72FAD41DE5940D0FE11CA578D79461A99B58EE832A399A0B55433600D61B5D9B20DAD9151437FEDF9772D4D384AA9B240EE11FDA17533D67D13BC583562DA707B7EAA4214CE7BEA8B7E88AECF65ADFE08D76C0B940A5BDC70E728BEB05A4BF89952482A355916255C71A1D1450279A6022E2802BFD09F226CCAFB2433C8375A66BBFF46E2A180037AD653C7218FCE1DBFFF00F18989399A4BF5E4A5601C409E1774B63685461F8F2C9BAC1BF9E4063CF262C5BF24BC2CDE64DF040663A16D2CAF7BE49F8EB11D66405C98EBCA8A2A967AD779C1893CFAC5547C4777D60AA43352E527C9020A0B978F8FC15BDB147F95DF145C46B99AAB01683CEC38D8C6FF6AF4DCC16A4A3B1E31A36F9C9361FB13527CFDEA5428B15A5115B647CFB0", + }, +} + +func TestKeyGen65(t *testing.T) { + for _, c := range kenGen65InternalProjectionCases { + xi, _ := hex.DecodeString(c.seed) + pk, _ := hex.DecodeString(c.pk) + sk, _ := hex.DecodeString(c.sk) + priv, err := NewKey65(xi) + if err != nil { + t.Fatalf("NewPrivateKey65 failed: %v", err) + } + pub := priv.PublicKey() + pubBytes := pub.Bytes() + if !bytes.Equal(pubBytes, pk) { + t.Errorf("Public key mismatch: got %x, want %x", pubBytes, pk) + } + pub2, err := NewPublicKey65(pubBytes) + if err != nil { + t.Fatalf("faile to parse public key: %v", err) + } + if !pub.Equal(pub2) { + t.Errorf("Public key not equal: got %x, want %x", pubBytes, pub2.Bytes()) + } + privBytes := priv.PrivateKey65.Bytes() + if !bytes.Equal(privBytes, sk) { + t.Errorf("Private key mismatch: got %x, want %x", privBytes, sk) + } + + priv2, err := NewPrivateKey65(privBytes) + if err != nil { + t.Fatalf("failed to parse private key: %v", err) + } + if !priv.Equal(priv2) { + t.Errorf("Private key not equal: got %x, want %x", privBytes, priv2.Bytes()) + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigGen-FIPS204/internalProjection.json +var sigGen65InternalProjectionCases = []struct { + mu string + pk string + sk string + sig string +}{ + {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}, + {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}, + {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}, + {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}, + {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}, +} + +func TestSign65(t *testing.T) { + var seed [32]byte + for _, c := range sigGen65InternalProjectionCases { + sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + mu, _ := hex.DecodeString(c.mu) + priv, err := NewPrivateKey65(sk) + if err != nil { + t.Fatalf("NewPrivateKey65 failed: %v", err) + } + sig2, err := priv.signInternal(seed[:], mu) + if err != nil { + t.Fatalf("failed to sign: %v", err) + } + if !bytes.Equal(sig2[:lambda192/4], sig[:lambda192/4]) { + t.Errorf("signature mismatch(signer's commitment hash): got %x, want %x", sig2[:lambda192/4], sig[:lambda192/4]) + } + if !bytes.Equal(sig2[lambda192/4:lambda192/4+encodingSize20*l65], sig[lambda192/4:lambda192/4+encodingSize20*l65]) { + t.Errorf("signature mismatch(signer's response): got %x, want %x", sig2[lambda192/4:lambda192/4+encodingSize20*l65], sig[lambda192/4:lambda192/4+encodingSize20*l65]) + } + if !bytes.Equal(sig2[lambda192/4+encodingSize20*l65:], sig[lambda192/4+encodingSize20*l65:]) { + t.Errorf("signature mismatch(hint): got %x, want %x", sig2[lambda192/4+encodingSize20*l65:], sig[lambda192/4+encodingSize20*l65:]) + } + pub, err := NewPublicKey65(pk) + if err != nil { + t.Fatalf("NewPublicKey65 failed: %v", err) + } + if !pub.verifyInternal(sig, mu) { + t.Error("signature verification failed") + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigVer-FIPS204/internalProjection.json +var sigVer65InternalProjectionCases = []struct { + pk string + sk string + message string + context string + sig string + passed bool +}{ + {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false, + }, + {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true, + }, +} + +func TestVerify65(t *testing.T) { + for _, c := range sigVer65InternalProjectionCases { + //sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + msg, _ := hex.DecodeString(c.message) + ctx, _ := hex.DecodeString(c.context) + + pub, err := NewPublicKey65(pk) + if err != nil { + t.Fatalf("NewPublicKey65 failed: %v", err) + } + if pub.Verify(sig, msg, ctx) != c.passed { + t.Errorf("Verify failed") + } + } +} diff --git a/mldsa/mldsa87.go b/mldsa/mldsa87.go new file mode 100644 index 0000000..84e1292 --- /dev/null +++ b/mldsa/mldsa87.go @@ -0,0 +1,500 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "crypto" + "crypto/sha3" + "crypto/subtle" + "errors" + "io" +) + +// A PrivateKey87 is the private key for the ML-DSA-87 signature scheme. +type PrivateKey87 struct { + rho [32]byte // public random seed + k [32]byte // private random seed for signing + tr [64]byte // pre-cached public key Hash, H(pk, 64) + s1 [l87]ringElement // private secret of size L with short coefficients (-4..4) or (-2..2) + s2 [k87]ringElement // private secret of size K with short coefficients (-4..4) or (-2..2) + t0 [k87]ringElement // the Polynomial encoding of the 13 LSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the private key. + a [k87 * l87]nttElement // a is generated and stored in NTT representation +} + +// A Key87 is the key pair for the ML-DSA-87 signature scheme. +type Key87 struct { + PrivateKey87 + xi [32]byte // input seed + t1 [k87]ringElement // the Polynomial encoding of the 10 MSB of each coefficient of the uncompressed public key polynomial t. This is saved as part of the public key. +} + +// A PublicKey87 is the public key for the ML-DSA-87 signature scheme. +type PublicKey87 struct { + rho [32]byte + t1 [k87]ringElement + tr [64]byte // H(pk, 64), need to further check if public key requires it + a [k87 * l87]nttElement // a is generated and stored in NTT representation +} + +// PublicKey generates and returns the corresponding public key for the given +// Key87 instance. +func (sk *Key87) PublicKey() *PublicKey87 { + return &PublicKey87{ + rho: sk.rho, + t1: sk.t1, + tr: sk.tr, + a: sk.a, + } +} + +func (pk *PublicKey87) Equal(x crypto.PublicKey) bool { + xx, ok := x.(*PublicKey87) + if !ok { + return false + } + return pk.rho == xx.rho && pk.t1 == xx.t1 +} + +// Bytes converts the PublicKey87 instance into a byte slice. +// See FIPS 204, Algorithm 22, pkEncode() +func (pk *PublicKey87) Bytes() []byte { + // The actual logic is in a separate function to outline this allocation. + b := make([]byte, 0, PublicKeySize87) + return pk.bytes(b) +} + +func (pk *PublicKey87) bytes(b []byte) []byte { + b = append(b, pk.rho[:]...) + for _, f := range pk.t1 { + b = simpleBitPack10Bits(b, f) + } + return b +} + +// Bytes returns the byte representation of the PrivateKey87. +// It copies the internal seed (xi) into a fixed-size byte array +// and returns it as a slice. +func (sk *Key87) Bytes() []byte { + var b [SeedSize]byte + copy(b[:], sk.xi[:]) + return b[:] +} + +// Bytes converts the PrivateKey87 instance into a byte slice. +// See FIPS 204, Algorithm 24, skEncode() +func (sk *PrivateKey87) Bytes() []byte { + b := make([]byte, 0, PrivateKeySize87) + return sk.bytes(b) +} + +func (sk *PrivateKey87) bytes(b []byte) []byte { + b = append(b, sk.rho[:]...) + b = append(b, sk.k[:]...) + b = append(b, sk.tr[:]...) + for _, f := range sk.s1 { + b = bitPackSigned2(b, f) + } + for _, f := range sk.s2 { + b = bitPackSigned2(b, f) + } + for _, f := range sk.t0 { + b = bitPackSigned4096(b, f) + } + return b +} + +func (sk *PrivateKey87) Equal(x any) bool { + xx, ok := x.(*PrivateKey87) + if !ok { + return false + } + return sk.rho == xx.rho && sk.k == xx.k && sk.tr == xx.tr && + sk.s1 == xx.s1 && sk.s2 == xx.s2 && sk.t0 == xx.t0 +} + +// GenerateKey87 generates a new Key87 (ML-DSA-87) using the provided random source. +func GenerateKey87(rand io.Reader) (*Key87, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key87{} + return generateKey87(sk, rand) +} + +func generateKey87(sk *Key87, rand io.Reader) (*Key87, error) { + // Generate a random seed. + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + dsaKeyGen87(sk, &seed) + return sk, nil +} + +// NewKey87 creates a new instance of Key87 using the provided seed. +func NewKey87(seed []byte) (*Key87, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &Key87{} + return newPrivateKey87FromSeed(sk, seed) +} + +func newPrivateKey87FromSeed(sk *Key87, seed []byte) (*Key87, error) { + if len(seed) != SeedSize { + return nil, errors.New("mldsa: invalid seed length") + } + xi := (*[32]byte)(seed) + dsaKeyGen87(sk, xi) + return sk, nil +} + +func dsaKeyGen87(sk *Key87, xi *[32]byte) { + sk.xi = *xi + H := sha3.NewSHAKE256() + H.Write(xi[:]) + H.Write([]byte{k87}) + H.Write([]byte{l87}) + K := make([]byte, 128) + H.Read(K) + rho, rho1 := K[:32], K[32:96] + K = K[96:] + + sk.rho = [32]byte(rho) + sk.k = [32]byte(K) + + s1 := &sk.s1 + s2 := &sk.s2 + // Algorithm 33, ExpandS + for s := byte(0); s < l87; s++ { + s1[s] = rejBoundedPoly(rho1, eta2, 0, s) + } + for r := byte(0); r < k87; r++ { + s2[r] = rejBoundedPoly(rho1, eta2, 0, r+l87) + } + + // Using rho generate A' = A in NTT form + A := &sk.a + // Algorithm 32, ExpandA + for r := byte(0); r < k87; r++ { + for s := byte(0); s < l87; s++ { + A[r*l87+s] = rejNTTPoly(rho, s, r) + } + } + + // t = NTT_inv(A' * NTT(s1)) + s2 + var s1NTT [l87]nttElement + var nttT [k87]nttElement + for i := range s1 { + s1NTT[i] = ntt(s1[i]) + } + for i := range nttT { + for j := range s1NTT { + nttT[i] = polyAdd(nttT[i], nttMul(s1NTT[j], A[i*l87+j])) + } + } + var t [k87]ringElement + t0 := &sk.t0 + t1 := &sk.t1 + for i := range nttT { + t[i] = polyAdd(inverseNTT(nttT[i]), s2[i]) + // compress t + for j := range n { + t1[i][j], t0[i][j] = power2Round(t[i][j]) + } + } + H.Reset() + ek := sk.PublicKey().Bytes() + H.Write(ek) + H.Read(sk.tr[:]) +} + +// NewPublicKey87 decode an public key from its encoded form. +// See FIPS 204, Algorithm 23 pkDecode() +func NewPublicKey87(b []byte) (*PublicKey87, error) { + // The actual logic is in a separate function to outline this allocation. + pk := &PublicKey87{} + return parsePublicKey87(pk, b) +} + +// See FIPS 204, Algorithm 23 pkDecode() +func parsePublicKey87(pk *PublicKey87, b []byte) (*PublicKey87, error) { + if len(b) != PublicKeySize87 { + return nil, errors.New("mldsa: invalid public key length") + } + + H := sha3.NewSHAKE256() + H.Write(b) + H.Read(pk.tr[:]) + + copy(pk.rho[:], b[:32]) + b = b[32:] + for i := range k87 { + simpleBitUnpack10Bits(b, &pk.t1[i]) + b = b[encodingSize10:] + } + + A := &pk.a + rho := pk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k87; r++ { + for s := byte(0); s < l87; s++ { + A[r*l87+s] = rejNTTPoly(rho, s, r) + } + } + return pk, nil +} + +// NewPrivateKey87 decode an private key from its encoded form. +// See FIPS 204, Algorithm 25 skDecode() +func NewPrivateKey87(b []byte) (*PrivateKey87, error) { + // The actual logic is in a separate function to outline this allocation. + sk := &PrivateKey87{} + return parsePrivateKey87(sk, b) +} + +// See FIPS 204, Algorithm 25 skDecode() +// Decode a private key from its encoded form. +func parsePrivateKey87(sk *PrivateKey87, b []byte) (*PrivateKey87, error) { + if len(b) != PrivateKeySize87 { + return nil, errors.New("mldsa: invalid private key length") + } + copy(sk.rho[:], b[:32]) + copy(sk.k[:], b[32:64]) + copy(sk.tr[:], b[64:128]) + b = b[128:] + for i := range l87 { + f, err := bitUnpackSigned2(b) + if err != nil { + return nil, err + } + sk.s1[i] = f + b = b[encodingSize3:] + } + for i := range k87 { + f, err := bitUnpackSigned2(b) + if err != nil { + return nil, err + } + sk.s2[i] = f + b = b[encodingSize3:] + } + for i := range k87 { + bitUnpackSigned4096(b, &sk.t0[i]) + b = b[encodingSize13:] + } + A := &sk.a + rho := sk.rho[:] + // Algorithm 32, ExpandA + for r := byte(0); r < k87; r++ { + for s := byte(0); s < l87; s++ { + A[r*l87+s] = rejNTTPoly(rho, s, r) + } + } + return sk, nil +} + +func (sk *PrivateKey87) Sign(rand io.Reader, message, context []byte) ([]byte, error) { + if len(message) == 0 { + return nil, errors.New("mldsa: empty message") + } + if len(context) > 255 { + return nil, errors.New("mldsa: context too long") + } + var seed [SeedSize]byte + if _, err := io.ReadFull(rand, seed[:]); err != nil { + return nil, err + } + H := sha3.NewSHAKE256() + H.Write(sk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + if len(context) > 0 { + H.Write(context) + } + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return sk.signInternal(seed[:], mu[:]) +} + +func (sk *PrivateKey87) signInternal(seed, mu []byte) ([]byte, error) { + var s1NTT [l87]nttElement + var s2NTT [k87]nttElement + var t0NTT [k87]nttElement + for i := range s1NTT { + s1NTT[i] = ntt(sk.s1[i]) + } + for i := range s2NTT { + s2NTT[i] = ntt(sk.s2[i]) + } + for i := range t0NTT { + t0NTT[i] = ntt(sk.t0[i]) + } + var rho2 [64 + 2]byte + H := sha3.NewSHAKE256() + H.Write(sk.k[:]) + H.Write(seed[:]) + H.Write(mu[:]) + H.Read(rho2[:64]) + A := &sk.a + + // rejection sampling loop + for kappa := 0; ; kappa = kappa + l87 { + // expand mask + var y [l87]ringElement + for i := range l87 { + index := kappa + i + rho2[64] = byte(index) + rho2[65] = byte(index >> 8) + y[i] = expandMask(rho2[:], gamma1TwoPower19) + } + // compute w and w1 + var w, w1 [k87]ringElement + var wNTT [k87]nttElement + for i := range w { + for j := range y { + wNTT[i] = polyAdd(wNTT[i], nttMul(ntt(y[j]), A[i*l87+j])) + } + w[i] = inverseNTT(wNTT[i]) + // high bits + for j := range w[i] { + w1[i][j] = fieldElement(compressHighBits(w[i][j], gamma2QMinus1Div32)) + } + } + // commitment hash + var cTilde [lambda256 / 4]byte + var w1Encoded [encodingSize4]byte + H.Reset() + H.Write(mu[:]) + for i := range k87 { + simpleBitPack4Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + H.Read(cTilde[:]) + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau60)) + + var cs1 [l87]ringElement + var cs2 [k87]ringElement + var z [l87]ringElement + var r0 [k87][n]int32 + // compute <> and z = <> + y + for i := range l87 { + cs1[i] = inverseNTT(nttMul(cNTT, s1NTT[i])) + z[i] = polyAdd(cs1[i], y[i]) + } + // compute <> and r0 = LowBits(w - <>) + for i := range k87 { + cs2[i] = inverseNTT(nttMul(cNTT, s2NTT[i])) + for j := range cs2[i] { + _, r0[i][j] = decompose(fieldSub(w[i][j], cs2[i][j]), gamma2QMinus1Div32) + } + } + zNorm := vectorInfinityNorm(z[:], 0) + r0Norm := vectorInfinityNormSigned(r0[:], 0) + + // if zNorm >= gamma1 - beta || r0Norm >= gamma2 - beta, then continue + if subtle.ConstantTimeLessOrEq(int(gamma1TwoPower19-beta87), zNorm)|subtle.ConstantTimeLessOrEq(int(gamma2QMinus1Div32-beta87), r0Norm) == 1 { + continue + } + // compute <> + var ct0 [k87]ringElement + for i := range k87 { + ct0[i] = inverseNTT(nttMul(cNTT, t0NTT[i])) + } + // compute infinity norm of <> + ct0Norm := vectorInfinityNorm(ct0[:], 0) + // make hint + var hints [k87]ringElement + vectorMakeHint(ct0[:], cs2[:], w[:], hints[:], gamma2QMinus1Div32) + // if the number of 1 in the hint is greater than omega or the infinity norm of <> >= gamma2, then continue + if (subtle.ConstantTimeLessOrEq(int(omega75+1), vectorCountOnes(hints[:])) | subtle.ConstantTimeLessOrEq(gamma2QMinus1Div32, ct0Norm)) == 1 { + continue + } + // signature encoding + sig := make([]byte, 0, sigEncodedLen87) + sig = append(sig, cTilde[:]...) + for i := range l87 { + sig = bitPackSignedTwoPower19(sig, z[i]) + } + return hintBitPack(sig, hints[:], omega75), nil + } +} + +func (pk *PublicKey87) Verify(sig []byte, message, context []byte) bool { + if len(message) == 0 { + return false + } + if len(context) > 255 { + return false + } + if len(sig) != sigEncodedLen87 { + return false + } + H := sha3.NewSHAKE256() + H.Write(pk.tr[:]) + H.Write([]byte{0, byte(len(context))}) + if len(context) > 0 { + H.Write(context) + } + H.Write(message) + var mu [64]byte + H.Read(mu[:]) + + return pk.verifyInternal(sig, mu[:]) +} + +func (pk *PublicKey87) verifyInternal(sig, mu []byte) bool { + // Decode the signature + cTilde := sig[:lambda256/4] + sig = sig[lambda256/4:] + var z [l87]ringElement + for i := range l87 { + bitUnpackSignedTwoPower19(sig, &z[i]) + sig = sig[encodingSize20:] + } + zNorm := vectorInfinityNorm(z[:], 0) + var hints [k87]ringElement + if !hintBitUnpack(sig, hints[:], omega75) { + return false + } + // verifier's challenge + cNTT := ntt(sampleInBall(cTilde[:], tau60)) + + // t = t1 * 2^d + // tNTT = NTT(t)*cNTT + var tNTT [k87]nttElement + t := pk.t1 + for i := range k87 { + for j := range t[i] { + t[i][j] <<= d + } + tNTT[i] = nttMul(ntt(t[i]), cNTT) + } + + var w1, wApprox [k87]ringElement + var zNTT [k87]nttElement + for i := range k87 { + for j := 0; j < l87; j++ { + zNTT[i] = polyAdd(zNTT[i], nttMul(ntt(z[j]), pk.a[i*l87+j])) + } + zNTT[i] = polySub(zNTT[i], tNTT[i]) + wApprox[i] = inverseNTT(zNTT[i]) + } + + H := sha3.NewSHAKE256() + H.Write(mu[:]) + var w1Encoded [encodingSize4]byte + for i := range k87 { + for j := range wApprox[i] { + w1[i][j] = useHint(hints[i][j], wApprox[i][j], gamma2QMinus1Div32) + } + simpleBitPack4Bits(w1Encoded[:0], w1[i]) + H.Write(w1Encoded[:]) + } + var cTilde1 [lambda256 / 4]byte + H.Read(cTilde1[:]) + return subtle.ConstantTimeLessOrEq(int(gamma1TwoPower19-beta87), zNorm) == 0 && + subtle.ConstantTimeCompare(cTilde[:], cTilde1[:]) == 1 +} diff --git a/mldsa/mldsa87_test.go b/mldsa/mldsa87_test.go new file mode 100644 index 0000000..13df5c0 --- /dev/null +++ b/mldsa/mldsa87_test.go @@ -0,0 +1,198 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "bytes" + "encoding/hex" + "testing" +) + +// https://github.com/usnistgov/ACVP-Server/blob/master/gen-val/json-files/ML-DSA-keyGen-FIPS204/internalProjection.json +var kenGen87InternalProjectionCases = []struct { + seed string + pk string + sk string +}{ + { + "631AFC2A36A57E1D090DADC2791D486D72C69A9AABF97990C573214846FE5B64", + "573449AE1772430DB958DD78747F0AEFC03F6DDEDCE592D5F4B517B38BCFCB90E6C1DF44CE2CE4D3C6A5682D057DBDCFCED3EA58EA125437F6B896A473CE4880FFBB97C2C0750D41D1B7C00E2106137DAE49609DD630A23D5D498D546625F80E29A6B18B01DE399FAFC911EEAC4A97761EC0197359A1E4B3930DB17A6144BD7B2B3C93DD1F21A0562CE6C6D1128F6589498E6133F98164D544C888A1DA5A5E266E7D1864FAB25708CE6B607C11D52B0F582F6368BFD733259275B099BCB500FA62B5E366CE2093E89CD3EFFE8DD3CF2CD01AC8176BA2352333FBE044CF5FE09553A318F05F055B83C7239DAF268C27FC85F6A41EB580570BA6C598A64C3F0956AC91EE58814E3EE09F69718CAECFE8C0BFA6CDECE733B656D5EED9F39FD7AB9F0790964D7FC0E6FBF2A9781539875179ADA3A8771288C957D478AA47E800768743B2CEE8BD228DAB02E049EC6432B9A2D21AB77FA313213EBD9C59E8591A480E7EB51B2237EB717F7B1DE684E6FBB8AD78AF5F032D752CC28B4B03A537156CAD9D073B4F50AD8C869DB0BADC7DBAFDEC5D92EBFB00E2BA9C85327988D09CA90C2FDBB219E5A75F8578D7D4A2AD53A0E04B7D904F4C6939AA16435D14D61396D47CDB5F278FB87839B1EC857C9D818B917ACE3D3450BEE9D0E51DEBDC64DE38DE70429BF7DFC0880817BA202840A3CB838D45373F553C5CD30CD136C2D3F3837FF9114022A2DA73048CA53799594F353CE5320F2E921B927627D7F6741BC95B03657753B64A9513328FE949CF19A0986A89BBEEF409E9ACDB73DE81FEA6482D31C05EEDE5011463F48B177534E035089FC98AFB928989250C5521BD9BD877EE80F1E8A70776F951DDD29ED96851F14F873A54619958DCC35742F8BC27DA8FCE7F2BA4FCF2C1B7BDE01DAAFDE20B91C9C255D2AFDC5D4E692CA92549C597E76D4407B2A02BCC9683F7E0A3EDECBDFE4AA400CDAA92FCB10937AC4441116E67D0C7D734BACCED4DF8F499935D84BD57F940FBE69229B0E169B50E30B40792645AD9A1A7B0E32AE4D295C7C6037E9ABCD0D34942EE116BE75ACA4D1E34AC92896F3F34BD9E7400787EAE0DA690B670E05AA33568CD9C348083FFFEBA872D855028E20E2B0877DF4C8311B1667F340E67580A680489D4A064D818D386F113BF515F0A9C953D3708D90BD35930FC6D869FFBC43CC0F2EF8ED4EFFBA778DB0E926060CBB23ED4A37A1A253065A2DC3D06EA53AE2AB42288C272ABED849419CF1845DC3A5410DA5F624E722976610E3F8F483920C46A41F1FE6483A6EA280C7CFBE41ACF1612039CF148EFC821C43D0D34753B8B5EC50FDD184B07C4BC9F49D1FAC197855558D345172AF54C382D219F368E46EBFA8E3AB18162E708F186635EC445BBCF1F4F6C83EF6511F940BC2150651C5FA95AC1F5DA4AB96D331001BD9E0A1F41D47916A7E206AE8C140650DA2A91BB7043EDF2942923946352AF35DD7267550F4CC78EB6EBFD79DA1426326ABC102557DBC40C004BD8EEDEB543FA9783E0204868166331859AA9508C1F4E83FAE9D7E02B305AC9C529217DE124E59CF9D007E5A459A17A6F1E19B215560D49B26A171A2EC082C220BF407BDB75CA962321B7865D73E8EA7070B73F93ED69A14D3CF35B111510EF6098A08A9745EA7980D99A44B4CBE10B126CA5C61F1CD0B4DD2CD3D51CB72A9CC34BC61D318E3CCC7D1C04511DFE865C590CD952E07D26BD9162795AB5D5D44F59A388F9CF71ABA85AC24CB6EBE570BD7DEE2F1621DC509C4A269E6B4A9E66068D45E95A7EF9A394CCEE13ACF893A5ADCF8112DA077E3DEADABC6B8ACFBF598DB0496D2A3D6C58723AEA49B8267D1656D94437A0830E22E509B8159B1116C5ADE2D1EB2601CB1399B3C6AE97A15F932F7538A74E0050ECC615B0F4BABB82F5834AE643A5F4834679C65E0C9674EE568553625EC79BCED33065C11D33D34928A604C061677D07BBF68457D07892C46C885AB7CCD2E52B8C5189C73F5567D2126A1B910EC93B4F1599CA1A4ADAE3C7846738106E2BBEE5FA94FF46DE342F8F029B4EFFD4065D522DCC2CF6205C053B33BD6F4F9A7864FB7FDF5284335F5E4299DFB181F9E572575F459BD1B28FE4E355580DD8D555A4511C5C35F96025BC935195EC7F6A5E0339F82B325098A244B93FDE10CCC78A6DD1023416715081941999D613A5C9F9297CE8CC9ABBFA2DF69F353AD3E43BA5241877BE25CD32824A121C504E8607C7897E5CCCA0D9AEFE682729CF4CAA7907869CBAF240CBE28B3895608AF01776B6DF1C3FA28FDC54F8E0E631766F6A13274FCF167EA1A50811BB1485D8D0FD7316EC2A02D525CA6CB93889439B9A19B977B310054A872E0AE6ED0C4557A4BA2DAFB6D68CC8057A447C38F88ECCC53B81DAE5E3D916242336AF7BD3FF7450CA3D1937E1E7D2247467EBD530CC424FFDBA445693781495BCD8994750542B940E3F2BFEFBD3E5FD634BE14F9017861384BD96B9D0F9BAAC99F6A611FB35167AE4F64B4E4C133F02AF3A121023D6305A95475A04F102B057EBD7ADDCF8D06D0AFC452AF20D808533F41AE4BB0F05FF7D7132972238F071BB69F6E6AF2C9935B88FEDDE5D53D7C74D7BC17B756F65964F647ECB4A3BC7E8BBDB60B12789E93847E54D433170E2CCA3251946A570A62CD0358E53EF51DB256E1E2C997E0CD67B5EB68A1B6285CC1E23388D62C67D4149B5C1AD485F4CB0DF4704A65A04E2B2F6CD494013CD27F0AAD410A0211D465C22392F39C4FD38B620B4B40FF23234084AFB9A54F85097A51E447336A57A29F216D15D61F34B7EC14108949CDE4249E3C0C39DE8A2C64841F8C450A9133A7AC73FC72C7863D25186699C1AB63103848722C258200398EAE468522C3BA2E4B23B0326094A0977633A8709DB1C572A041D1EBA987C8422B0E2BB96A51E4DBFFF7C308E4A4AAC65B871FCCA6CD7A4FBD273ABF1312CD6C2A8C17579C2286C89ABA36A0A7CA9FCA60E8687ECB1A4B82EC41E35F7F55C5897E2381D73E5D501F9C0DBA77EA1C5D0B4CEEFCDCC321EE2A3DACC0198E1FC32887DF2EE117DB6A45AF2C4D265EF05F90BDB4F83FC797018D8B76B21C7A7FBAF33EA0D5D9CA046EB8DCF9C0B7090C9CFBF53B938DA83318F8D73EAE8323ADD404B0BB51907E1FAB61ADC7E330717F483B833DB6932AFBB1EE49C333B69499FAA6FE38051CEF145514C5BFEBD79A397F0781746ACF120DAACE3714DCF67B09783E70347A22302953B77ADBA1CB64E06E640EDB3243BF6D2B9787B5F9D2658F63F3681EA9876658EEE107FBFBD2D70A70F3C9A597E95900D0DCB89F9F7596D0E523F0D904BD27A727561E4E899441DAA86A723BF403FD15E87337D0D032D20D5B49AB96A39D5EEC75CF45AF7D396F09F5CD25186259BFF1B67DCC33D8E056C95957B33CB033188750E28312B6041AD1743EAF823DE565743197132AB925987FD4DB14225537FEF2D39EFBBA9D8AB6B5289CAC6BC2A906C2FCF66F7BF3C71BEAE2BDCEEBB2791FD4302FAC56630A235243DA8F88CE77B88BEC1AC37B93A71623D58DF8C2074D7B2F68789DAFAA714F5F8968642A1B58FB02C99B01F11650D807C1A6E39BBE7CF22B7640505A9B97A253C7A32FBFD2C1A6A600068CFA2B3AB7E9F3120D6533344C19CAD82", + "573449AE1772430DB958DD78747F0AEFC03F6DDEDCE592D5F4B517B38BCFCB90DDFA07172427FFD257AD7EB9DB575368266E6E511EF45AFC232549F76D699E8CDA8503613B6F964F264E5F27BFC0ECDE340E0910D4F9130E4A86E7D1E0C5EE04141781DD4E030B91A9775DB1007EC1DC68A1DD7F57DF26D14D2A22FD17F8E182D0402618C0314820411C05265914248C422AC8182C1BA1315B144E082042182850A3045250C811122591C10402132810D2422E244065E13684844064D4082AC03665881008CB444603244DC4A20DA21250A4C6919C446292C684844085594049E3960809106023B98D92A400634205993210998248821024CC3001DA242E1B40099C3402C3804014871162C04C20B589D8B684DA002601277203B20D23C361CA281223B84C18918D23B24463C22418498521B985513821238905C2186501490E04C10024028A2496309CC0209A326043286961146CC016669C1000E014420BA5695BB62C18264442284DC04424DA22114B245009C86983484002B67110838408B36841866523438C484280033750DB364189960892B86C1A138A09383019324A4B084920C70C0B4384008465E30849519011039140DC4611D434411A164613436260944DD4866D52888C231664DC82450C488893B620C31204CA3684593626612229E1028EC8B02D51144C1CA609413829D4068983C8809C82844AA04D0CB288A2B245000405C2324689C84510107010360CD4868D0102308B220C90822110C2501C112EC31611821649431291D08241604260189971224325A1948118C101A2800D5208915132640886110B02925B14884380806124525204000A2185D444060C90480B132614B16813998C02C40110C1684A02910A036C00458914C74D80A82008802922282A0480049AB00181124020296E93B0291B916023C4849A8064C01462D4046020472D98C240DBB808A324110A16500B90518498852118081C1349E3982940286CDA102808957011C124001231A4B885C1480E02B36852064151346E149890820429001505DAB470A428284934708A2201A3922501253000070582366E814260224512C02809DA1008D0408164B690D312100004014CC848DB8400621001DCC850D424691AC2290C473144180EE2B620A2920D10A501000644C302484CA851C302421CA78903488ADB2642583425C3460AC8084CC9804D9192800425851228024C4420D0224424824CC0C4901C246141A64089944549020E64284E20B044DB2232D31211CAA450833488A4407251A88C5886110C484AA38404A21862E3369299124680249144C24501426D64220284186A231826E2024913001183324D2447422489008B42605A082E02B0291C490248C28D524851183221CA926190A66D09096148B42C01406E84089188024019830904158EDA346262A84802469010480401A365C94288221010D0422E84C868643429DAC68160B24588928D2443004C108DD1229249426010A58942046C91A2811A8110DA464E2208450C8144D84469C8A831C88265641832C3C64CE1C208208465DA006504B50C02952C5026891B4151229825E3384AA002261A3651A0443043922051A62404115002B984C8126A1C35481B308003B085E4B4245326300C14809392481AC7098198114936041BA321C8A89008122189C8702380210C132849006182B02CC8129263A07021154E942244E41066044132202602C1A24812991060A444A148310A358E510291584648492685E31811844606643042624225202444C9042011910DDB164A014520230500C2C26D54444000222422404843387260186862B23112882C80B48D214344913692519824C496681012519C484ED3822810386A19A10181C2859CA2515B202008306A0B009293028601308C092846DBB88000212CC9B2291CC2480C26919B0066E22422029925232606E1B00D50200511074218B06154C04880C44090386C94C4300490095438822222864B323083A069DC924D124744CC444662924DA2B64092208C08C8090A060DC3B0701C032903972921076553924C12368481B80D19288204330CCC282D081260013628DA246AE4426914011101419041440C62062C244301D406461835201C00898C3808C2280D08330D09326254486580C0894B488C02B17102924DE42210C9B25119130CC0A48D01A445A1C8089A468A08156EE6F449D96577799FC7D8640359E8D7547D5A3B37DA3D4E9463C0C223B6976DDA071949DBE51DB7FCD7BB6EC01A6527B8BE1BC183DB42207990A0BA34363D2BD6AEFB461628799FA8BFB6DE0D69E47FD3F66D6FC32EEF091BC8655C788D0BBCD73EA7E71E86C2F15C00A97BC3457276B28A838470C6774993C83F431261778FFBA1247630C41F6AB91D6D14A76389E585E1740C59236D6143419E39232837F0D6ED87E6240B5860022925EE5CFE3EB492510F9350141062033AE96976B0A56ED11DC9822D57ED974D568C30320A5E87BAA6B18990B352E0E5821F71D9B8F9490A607D23E6AA5A3657E84679F13615A66A7E90B93DE823B59457E78880EDAB66267771334CCF1E7E3EA4560E59C0E8A4CA2C02EA35347FE60A7F33BA343CEDB2126C4948CC28DEAE5D76F5B83E5E662D32E8D112A0C5518D91A7CD99463F6B6CC334DF61E2A8436624EB5E41750D7CA3A494C303D50BAD156542BC726628982A98FC9112D7D3804889A1EC596E273BD0892307B601E1DD08EFE80446FA6DA1D50D730B1BAA83639CC6AC824C497EABEB528AAB329C1439EDF90F24D66C6D38FBB16A4C5FDAF767E68D7A823F82BBBC85356F2D1B26D4C80F738AB8620D5DDA3333A09E018143475549E2C05D96B535591F9B2ECB41E33EEDF3FE74AFCA455B79555ED2066DF5CC8776574A7D772D8C70A77E887280EF17D4799C8C2A1F950CC1A3DCD1D6733BA0DEEBE6FC975F121C28766F50EACFA4E4B1A388A6E6DA4933AC97C6712E3F14DD90794E7BB36C7C74E0B5A1E301A8BA90814DA233A055927818A1421DFEDF59DCE65B4B33E0925388FEC03431BE3C4AB4D347CF52DD6D9630467CC5A7E76B2CB81D5BDD515AEE674F1931D146F62104770919AD82C9D09719B8CFE435E42552306E3BDEC84A6075D710EAAE19EC1100BA8920549F2008DB74CB9AD75E6B776BD36D8D5D83DC0D483D1E3A2D4D45866E6F6833D67DD8147CA18785376A2D138A153EBB9E38EAADB3750CFBE5F91A9C405F327CDC472FBE27B6D862A62A9E10EBB720A99E53D4A37F83E5D039DDECBB77C8862DFBF9A645009235328D7C4CE36424836731B763122A9CC3CE341B72A4E590FAA0B2EF163DAFFDD6196BAD58EFACC78D8E7629CF379C6417F71F2A0FD2EA2A4D68A723BB3724758E2B32FE8298AA5C2922D5DF0BD1D62519D4E0783E07F1616F45C9E77EF6DF9808B38D0FB057FA4A87D74519F30D8C8C261EB174B32AEC5BE41B025E0A907E54C3F8A2981A88D9A4EC6A2CE4AA5B59F0028B689DA910D6C0414EE778250E484A4290F5654F435CF194FF463E122EF1E17E5A510E2E556630E8CE6D3AEA34A607C20C4C6473ECBE9FD83FB3EAC9085D9E3D41C984FF96B46D3F9BEE7F4C8E13DDDFE6908360248593AA04D2478E214DCBED0B43474DEBBDAA1322C4EEEB7FCAE42EBFFD533BB847C32C1789CC28D412F4589E5C8DCE7D15A3F886E31615E6B231892D7BA789DDE2D51DA4CD442F63C40326344E47B015BF84ED98ECB806499FB5640D83A57A68FE3F5ABEC50BC124DA29E20BBB5CC45AD9EE7639007A132CBEE814454C8BEBAF2DB0E4986682B391C1452FA05774F659013B4C9E6C0B90DFF2CA8149A7C609DFC7DE3D29F36A90012B2F17D050D38D4B1EC03B92A4965823C2FB716C8583A09C54412604CF629DDAEC4F56EFFC00CCF06232584B6131BC9EBA626ABB934284FE688F8D87192ECBC933157BD5B4F39C4651434F64D9B4BE5E5011C322045106C7C9DA1B56089EFF239C94C7E42CBB56068CB71A067ECFA0A14703C22B2015BEB057C1B4934E05C7A73B3E2ABE8F170010DCD4A7A8F0B88E9C0492E9F85209A73DC1587FA1C518D3DB7C67E4398E90A42E579AE19F41505143D778842D095D09445BABDBC78292865D059E72AF458BC7BB8B2945017C18D1EF74255F3D7122BBD77B42C0BB4503B3BE05A8E210D269C53DCA629EDDEEA33EF28B78B3039E645B5F8106DDBA21655388CBB86000CECEE265B989F3CDE09A9C4F6960BA8C051149CC296DDAD10F4C8D4F8F8836A80126CF331D8F7FC94C6D9EDD8AED1E0D5F16E69352B5FED97A8BF27BB9134F2D6FC486AB49D81C8A6975513F4774992DA6701F5DC9227CA5B258BDD5AA69E65517BC323052A13BE689117EFC50310AF2384DB16884F1046A16D70351C07CC383E01A1F27E6EA9ECD877E50C4FA3ECE6F9A62BC18BA5466180C37265992AEDFA130A30D2ACE3C4D0D60D18D872F23F04404BB3B5F5A55659860F57498AABE866AB528E04DF18440F59D04EACDFEBD8853DD62EBF56535FCE3EA8D3C8FE8475EBB3103F8CC1D5447495F94BA93E438B92EFC62EAE24081DCCF18A73F761E2E33C5269D80A8295E5C61C2106E635E7A0B0EA36115A38292D7BE9A1B24451B78E0EEB36F51FFCD5CBE5FFEF585A945DA5F2DDB2F20E89905AC86FCCB8393C85D6A44DD6E8E4596CEA5763C10FF6A0A7521A2BDC5D4954EC894154972A7BF13FC188AB355A1D1032DB05388FFF1D45FD0312DD55D1C484927356DFAEFC81585634CBBA53F5C179AEE1F4DB63017D8C0A334AAF7D55E0435DDD3024AD2C14D5DE130883735BF060C1EEFE95CCDA3F3CC2334EAF03426B2BCF97D5DDB097C1C1E926723EB53528437019C0C8BA32706EBD907A9C56E94889F37EB39C87C3767C0E816F0231C12D22F37B9D451D4E92E8BDBFB93B1107647409DFE8156E763AF54CE5CD55186B6F44C6170C1AD8912F624948227C8F816B7088A8810387935EEC53DFEA3DE762B6FED2166C0213A3C0955456E14A259CD7F62C1D4ED3A94DCD607B331C9962DD639B5A0D0130042A1981C6D1E03D347B30F2851933505A2E28A46874B9E6AC33752B04E26A888EE6952F573CC29A73142EBCCEE57F8BF9CEA31EBF00BEABBDD4EDB3CCCDD2E63378CFD8C4165861BAF1F35710B201733CCF30B92BDB799B6A9E1BF1B533767A5CE6386471FC427993DCE2254C76B2A868C97FEB3ABCBC5FE07D2CA40BE64791304FDC24AF76D4F4EA2F38F92D151249AA5F9AD80B4674242F6DFDE5716DAD56266860F410EDF203B94F3D26F93683A7CAE0090DAE1391A006092C6F4D6467E332EBB5066AD35DED45F5F72B082037A313C70B261F616F4726ADE29C5762DD5B9A19960A7C2588159DA5D24BC4F7D1596DCE0540544F5F81A67BF52A954C70DB1D15353C6FBBC3ECE115B0CC3641D2A3F33E7C01ACD395C8D20240B0D01F44E2E8EB25F2D130BD1033FB86779C7803448F3493683A6107CC79F7D99DA2723A8110419727E128A47EA98DEFFE4B97B4387F73A5A8F9D840F54E49CD18A9CFA4A1883FB6B023A7F9C5EF31870BA7376DEE06312D2F25FE8733622F18BFB1DECC280837FEA9F8BE53E8B3F069964D8D6A2E362C3CB0612DFB7D51418255562213D0E61BAA37A2DC86577C7139BCBF81D2A3A688947935EFE7956120302E9DDBFCE3B9FBCE8A9391538627BA92150256A4AAA92635A294B9898143ED3D57231569FB9B1DC5F6FDD982594FC3A575EF005658E6775041479107DF46A3B0B892BC648E7E5CB72E45EB2F4E32D188A23F524E8A4337911706EC489175744B54DC3DD0E189E8C00A5A6391850BFD482594AB72558B1D6B8154A7EAFB4D41045C534C9A4D42E128E554519876E08712F6D3944822CAA05781E2919941312F34BF6121971A3EA7362DD2E057D4902300029D0CED942BA527CF78CEA76222E1915626CA6CDAED1D5B3741E692820AF6E56B9EF4A7F30488139B54B6859F4F452B5BE960D259DB74D6BC1D10A8F4C22A297A6108F461DC68A24B95CC339E928D8799E70C5B161879132940FD7B5269B36C77DAAAFC79D001C1AD5EFBEFE2397856AB304CA70412C5B2DB30702B12788F7E59A063250AFE964006FCEE7C6724B744FB56F73637D6F4F0CFF58D626CF852E76842FB5C21A7E538FEE62F0EF56623E2E02F42AE9B2ACC31FC5B383C331D3EE4EDD5788D2E3DA4632FBAE0FF4A55FA8A57A274B7ACAC98883D55087A65BC123643161DA05A2AB76D01C120E188F60C4115AFD7BAFE3119EC7EF7D254542458C67A25C8C7487FDEB5ECFF8562DE1C4C80CDCAB96AB08F642D77E888CAAC1031F581BBB2261229E65832B6591BE49DB1428D22A08EAFB828996472AF3C74ABD2721FC31B7181427EB81894E04D72BEC3A34C347FF5119C49042572F14056D63AD7B8CFC5319A84ED122775690F79FDC91785EF8D68F7E9A367634FB71317A8209457735022DA168B5B4CE8DFAD8021435FEEDB91C93A7E5FD78FADD72F0310E752149EA50C6D207DADA8C268E4956C22A713A98690F32BE0324BBA116303718D380913ABD07A1C42E6B1A833D3B73D9B627BE9EBEF1072E83BA1E15C37558F3A41B6A0309EAAE299A22B9B73CBF7C200FDFF10AE0EEA71D5FF2CCE37F712AEA212BD39A4141A8AFB96808FD6032FF740066BE5661DC929E7A35C30E4973958123FFD8210CE3747A58BAFAB2DC0E1E67CFCDDC2D5C2731859DDCDC915763AD3B01012ACF1AE82C830216FC0F979484450B81CC5329D5642118E35764073F11C9D6E7C6944261A63B340885B12329566AECBAC845A27DCA70BD79BC1D195B43D83974F3F97861594B502D75C830B68F0792B6BD66FB8A44DA6EE38ECF9167A7143ACA3CC20494D737274A10689F297721D7C0A8DEF1A806639DC4C78BB77D", + }, + {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}, + {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}, +} + +func TestKeyGen87(t *testing.T) { + for _, c := range kenGen87InternalProjectionCases { + xi, _ := hex.DecodeString(c.seed) + pk, _ := hex.DecodeString(c.pk) + sk, _ := hex.DecodeString(c.sk) + priv, err := NewKey87(xi) + if err != nil { + t.Fatalf("NewPrivateKey65 failed: %v", err) + } + pub := priv.PublicKey() + pubBytes := pub.Bytes() + if !bytes.Equal(pubBytes, pk) { + t.Errorf("Public key mismatch: got %x, want %x", pubBytes, pk) + } + pub2, err := NewPublicKey87(pubBytes) + if err != nil { + t.Fatalf("faile to parse public key: %v", err) + } + if !pub.Equal(pub2) { + t.Errorf("Public key not equal: got %x, want %x", pubBytes, pub2.Bytes()) + } + privBytes := priv.PrivateKey87.Bytes() + if !bytes.Equal(privBytes, sk) { + t.Errorf("Private key mismatch: got %x, want %x", privBytes, sk) + } + + priv2, err := NewPrivateKey87(privBytes) + if err != nil { + t.Fatalf("failed to parse private key: %v", err) + } + if !priv.Equal(priv2) { + t.Errorf("Private key not equal: got %x, want %x", privBytes, priv2.Bytes()) + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigGen-FIPS204/internalProjection.json +var sigGen87InternalProjectionCases = []struct { + mu string + pk string + sk string + sig string +}{ + {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}, + {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}, + {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}, + {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}, + {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}, +} + +func TestSign87(t *testing.T) { + var seed [32]byte + for _, c := range sigGen87InternalProjectionCases { + sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + mu, _ := hex.DecodeString(c.mu) + priv, err := NewPrivateKey87(sk) + if err != nil { + t.Fatalf("NewPrivateKey87 failed: %v", err) + } + sig2, err := priv.signInternal(seed[:], mu) + if err != nil { + t.Fatalf("failed to sign: %v", err) + } + if !bytes.Equal(sig2[:lambda256/4], sig[:lambda256/4]) { + t.Errorf("signature mismatch(signer's commitment hash): got %x, want %x", sig2[:lambda256/4], sig[:lambda256/4]) + } + if !bytes.Equal(sig2[lambda256/4:lambda256/4+encodingSize20*l87], sig[lambda256/4:lambda256/4+encodingSize20*l87]) { + t.Errorf("signature mismatch(signer's response): got %x, want %x", sig2[lambda256/4:lambda256/4+encodingSize20*l87], sig[lambda256/4:lambda256/4+encodingSize20*l87]) + } + if !bytes.Equal(sig2[lambda256/4+encodingSize20*l87:], sig[lambda256/4+encodingSize20*l87:]) { + t.Errorf("signature mismatch(hint): got %x, want %x", sig2[lambda256/4+encodingSize20*l87:], sig[lambda256/4+encodingSize20*l87:]) + } + pub, err := NewPublicKey87(pk) + if err != nil { + t.Fatalf("NewPublicKey87 failed: %v", err) + } + if !pub.verifyInternal(sig, mu) { + t.Error("signature verification failed") + } + } +} + +// https://raw.githubusercontent.com/usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/ML-DSA-sigVer-FIPS204/internalProjection.json +var sigVer87InternalProjectionCases = []struct { + pk string + sk string + message string + context string + sig string + passed bool +}{ + {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false, + }, + {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false, + }, + {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true, + }, +} + +func TestVerify87(t *testing.T) { + for _, c := range sigVer87InternalProjectionCases { + //sk, _ := hex.DecodeString(c.sk) + pk, _ := hex.DecodeString(c.pk) + sig, _ := hex.DecodeString(c.sig) + msg, _ := hex.DecodeString(c.message) + ctx, _ := hex.DecodeString(c.context) + + pub, err := NewPublicKey87(pk) + if err != nil { + t.Fatalf("NewPublicKey87 failed: %v", err) + } + if pub.Verify(sig, msg, ctx) != c.passed { + t.Errorf("Verify failed") + } + } +} diff --git a/mldsa/sample.go b/mldsa/sample.go new file mode 100644 index 0000000..41c15fa --- /dev/null +++ b/mldsa/sample.go @@ -0,0 +1,168 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "crypto/sha3" + "crypto/subtle" +) + +// Algorithm 30 +func rejNTTPoly(rho []byte, s, r byte) nttElement { + G := sha3.NewSHAKE128() + G.Write(rho) + G.Write([]byte{s, r}) + + //TODO: optimize to read a block once + var buf [3]byte + + var a nttElement + var j int + + for { + G.Read(buf[:]) + // Algorithm 14, CoeffFromThreeBytes() + d := uint32(buf[0]) | uint32(buf[1])<<8 | ((uint32(buf[2]) & 0x7f) << 16) + if d < q { + a[j] = fieldElement(d) + j++ + } + if j >= len(a) { + break + } + } + + return a +} + +// This is a constant time version of n % 5 +// Note that 0xFFFF / 5 = 0x3333, 2 is added to make an over-estimate of 1/5 +// and then we divide by (0xFFFF + 1) +// +// from openssl +func constantMod5(n uint32) uint32 { + return ((n) - 5*(0x3335*(n)>>16)) +} + +// rejBoundedPoly uses a seed value to generate a polynomial with coefficients in the +// range of ((q-eta)..0..eta) using rejection sampling. eta is either 2 or 4. +// SHAKE256 is used to absorb the seed, and then samples are squeezed. +// See FIPS 204, Algorithm 31, RejBoundedPoly() +func rejBoundedPoly(rho []byte, eta int, highByte, lowByte byte) ringElement { + H := sha3.NewSHAKE256() + H.Write(rho) + H.Write([]byte{lowByte, highByte}) + + //TODO: optimize to read a block once + var buf [1]byte + var a ringElement + var j int + + for { + H.Read(buf[:]) + z0 := buf[0] & 0xf + z1 := buf[0] >> 4 + + if eta == 2 { + if subtle.ConstantTimeByteEq(z0, 15) == 0 { + a[j] = fieldSub(2, fieldElement(constantMod5(uint32(z0)))) + j++ + if j >= len(a) { + break + } + } + if subtle.ConstantTimeByteEq(z1, 15) == 0 { + a[j] = fieldSub(2, fieldElement(constantMod5(uint32(z1)))) + j++ + if j >= len(a) { + break + } + } + } else if eta == 4 { + if subtle.ConstantTimeLessOrEq(int(z0), 8) == 1 { + a[j] = fieldSub(4, fieldElement(z0)) + j++ + if j >= len(a) { + break + } + } + if subtle.ConstantTimeLessOrEq(int(z1), 8) == 1 { + a[j] = fieldSub(4, fieldElement(z1)) + j++ + if j >= len(a) { + break + } + } + } + } + return a +} + +// See FIPS 204, Algorithm 34, ExpandMask() +func expandMask(derivedSeed []byte, gamma1 int) (f ringElement) { + var nu [32 * 20]byte + l := len(nu) + if gamma1 == gamma1TwoPower17 { + l = 32 * 18 + } + v := nu[:l] + H := sha3.NewSHAKE256() + H.Write(derivedSeed) + H.Read(v) + + switch gamma1 { + case gamma1TwoPower17: + bitUnpackSignedTwoPower17(v, &f) + case gamma1TwoPower19: + bitUnpackSignedTwoPower19(v, &f) + default: + panic("mldsa: invalid gamma1 value") + } + return +} + +// samples a polynomial with coefficients in the range {-1..1}. +// The number of non zero values (hamming weight) is given by tau +// +// See FIPS 204, Algorithm 29, SampleInBall() +// This function is assumed to not be constant time. +// The algorithm is based on Durstenfeld's version of the Fisher-Yates shuffle. +// +// Note that the coefficients returned by this implementation are positive +// i.e one of q-1, 0, or 1. +func sampleInBall(seed []byte, tao int) (f ringElement) { + H := sha3.NewSHAKE256() + H.Write(seed) + + var buf [64]byte + var index byte + var signs uint64 + + H.Read(buf[:]) + offset := 8 + signs = uint64(buf[0]) | uint64(buf[1])<<8 | uint64(buf[2])<<16 | uint64(buf[3])<<24 + signs |= uint64(buf[4])<<32 | uint64(buf[5])<<40 | uint64(buf[6])<<48 | uint64(buf[7])<<56 + + for end := 256 - tao; end < 256; end++ { + for { + if offset == 64 { + H.Read(buf[:]) + offset = 0 + } + + index = buf[offset] + offset++ + if index <= byte(end) { + break + } + } + f[end] = f[index] + f[index] = fieldSub(1, fieldElement(2*(signs&1))) + signs >>= 1 + } + return +} diff --git a/mldsa/sample_test.go b/mldsa/sample_test.go new file mode 100644 index 0000000..b23b703 --- /dev/null +++ b/mldsa/sample_test.go @@ -0,0 +1,33 @@ +// Copyright 2025 Sun Yimin. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +//go:build go1.24 + +package mldsa + +import ( + "crypto/rand" + "testing" +) + +func TestSampleInBall(t *testing.T) { + var seed [32]byte + rand.Reader.Read(seed[:]) + var count int + taus := []int{tau39, tau49, tau60} + for _, tau := range taus { + for range 1000 { + count = 0 + f := sampleInBall(seed[:], tau) + for _, v := range f { + if v != 0 { + count++ + } + } + if count != tau { + t.Errorf("sampleInBall(%x) = %d, expected %d", seed[:], count, tau) + } + } + } +}