swisspost-evoting-go-poc/pkg/returncodes/returncodes_test.go

47 lines
1 KiB
Go
Raw Permalink Normal View History

Due-diligence hardening + Rust transport-security layer Correctness/security review of the whole PoC, with fixes and regression tests. Cryptographic soundness: - mixnet: enforce the multi-exponentiation c_{B_m}=commit(0;0) check that was stubbed out with an empty if — without it a malicious mixer can prove a non-permutation shuffle. - zkp: derive all four Fiat-Shamir challenges via RecursiveHashToZq instead of a biased `hash mod q` (which also capped the challenge space at 256 bits for production-sized groups). Verification honesty: - protocol: VerifyTally now actually calls zkp.VerifySchnorrProof and returns the true aggregate result instead of an unconditional true. - protocol: persist the padded mix input (event.MixInput) so the verifier checks shuffle 0 against the same padding the tally used (fixes false INVALID for N<2). Other correctness: - kdf: length-prefix BuildKDFInfo parts so the info encoding is injective. - math: GqElementFromSquareRoot accepts the valid root q (off-by-one that could panic in HashAndSquare); RandomGqElement samples the full canonical range. - cmd: validate demo --voters/--options instead of panicking on degenerate values. - protocol: use crypto/rand in the demo driver (drop the last math/rand import). Transport security (new): pkg/transportsec exposes Ed25519 signatures and X25519 ECDH — implemented in Rust (rust/transportsec: ed25519-dalek, x25519-dalek), linked into Go via cgo. No RSA. Cross-language conformance test proves the Rust Ed25519 signatures interoperate with Go's crypto/ed25519. Makefile builds the Rust static lib before the Go binary. Tests: added unit/round-trip/tamper coverage for math, hash, elgamal, zkp, mixnet, kdf, returncodes, protocol (end-to-end), and the Rust FFI bridge. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:42:34 +00:00
package returncodes
import (
"math/big"
"reflect"
"sort"
"testing"
emath "github.com/user/evote/pkg/math"
)
func TestEncodeDecodeRoundTrip(t *testing.T) {
primes := emath.SmallPrimes(5)
cases := [][]int{
{},
{0},
{4},
{0, 2, 4},
{1, 3},
}
for _, sel := range cases {
product := EncodeVote(sel, primes)
got := DecodeVote(product, primes)
sort.Ints(got)
want := append([]int(nil), sel...)
sort.Ints(want)
if len(want) == 0 && len(got) == 0 {
continue
}
if !reflect.DeepEqual(got, want) {
t.Fatalf("round-trip mismatch: selected %v, decoded %v", want, got)
}
}
}
// TestDecodeVoteRepeatedPrime confirms a squared prime decodes to the option
// selected twice (the encoding is multiplicative, so multiplicity matters).
func TestDecodeVoteRepeatedPrime(t *testing.T) {
primes := emath.SmallPrimes(3)
product := new(big.Int).Mul(primes[1], primes[1])
got := DecodeVote(product, primes)
if len(got) != 2 || got[0] != 1 || got[1] != 1 {
t.Fatalf("expected [1 1], got %v", got)
}
}