mirror of
https://github.com/saymrwulf/swisspost-evoting-go-poc.git
synced 2026-07-24 19:43:51 +00:00
saymrwulf
ec4be74e17
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>
66 lines
1.6 KiB
Go
66 lines
1.6 KiB
Go
package hash
|
|
|
|
import (
|
|
"math/big"
|
|
)
|
|
|
|
// Tag bytes for the Hashable type system
|
|
const (
|
|
TagBytes byte = 0x00
|
|
TagBigInt byte = 0x01
|
|
TagString byte = 0x02
|
|
TagList byte = 0x03
|
|
)
|
|
|
|
// Hashable represents a value that can be recursively hashed.
|
|
type Hashable interface {
|
|
hashableTag() byte
|
|
hashableData() interface{}
|
|
}
|
|
|
|
// HashableBytes wraps a byte slice.
|
|
type HashableBytes struct {
|
|
Data []byte
|
|
}
|
|
|
|
func (h HashableBytes) hashableTag() byte { return TagBytes }
|
|
func (h HashableBytes) hashableData() interface{} { return h.Data }
|
|
|
|
// HashableBigInt wraps a non-negative big.Int.
|
|
type HashableBigInt struct {
|
|
Value *big.Int
|
|
}
|
|
|
|
func (h HashableBigInt) hashableTag() byte { return TagBigInt }
|
|
func (h HashableBigInt) hashableData() interface{} { return h.Value }
|
|
|
|
// HashableString wraps a string.
|
|
type HashableString struct {
|
|
Value string
|
|
}
|
|
|
|
func (h HashableString) hashableTag() byte { return TagString }
|
|
func (h HashableString) hashableData() interface{} { return h.Value }
|
|
|
|
// HashableList wraps a list of Hashable values.
|
|
type HashableList struct {
|
|
Elements []Hashable
|
|
}
|
|
|
|
func (h HashableList) hashableTag() byte { return TagList }
|
|
func (h HashableList) hashableData() interface{} { return h.Elements }
|
|
|
|
// RawBigIntToHashable converts big.Int to HashableBigInt.
|
|
func RawBigIntToHashable(v *big.Int) Hashable {
|
|
return HashableBigInt{Value: v}
|
|
}
|
|
|
|
// RawStringToHashable converts string to HashableString.
|
|
func RawStringToHashable(s string) Hashable {
|
|
return HashableString{Value: s}
|
|
}
|
|
|
|
// RawBytesToHashable converts bytes to HashableBytes.
|
|
func RawBytesToHashable(b []byte) Hashable {
|
|
return HashableBytes{Data: b}
|
|
}
|