Moves to Lagrange interpolation and adds a http-based demo

Author: Ruteri

blind-auction/auction.go

@@ -37,11 +37,11 @@ func AuctionDataFromChunk(chunk [IBFChunkSize]byte) *AuctionData {
 
 // AuctionDataFromMessage creates auction data binding a message to its bid weight.
 // Used by clients when preparing bids for the next round.
-func AuctionDataFromMessage(msg []byte, weight uint32) *AuctionData {
+func AuctionDataFromMessage(msg []byte, weight uint32, bytesToElement int) *AuctionData {
 	return &AuctionData{
 		MessageHash: sha256.Sum256(msg),
 		Weight:      weight,
-		Size:        uint32(len(msg)), // Size in bytes for bandwidth allocation
+		Size:        uint32((len(msg) + bytesToElement - 1) / bytesToElement), // Size in bytes for bandwidth allocation
 	}
 }
 

blind-auction/ibf.go

@@ -3,7 +3,6 @@ package blind_auction
 import (
 	"crypto/sha256"
 	"encoding/binary"
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -39,7 +38,7 @@ func IBFVectorSize(nBuckets uint32) uint32 {
 // IBFVector implements a multi-level Invertible Bloom Filter for distributed auction scheduling.
 // The IBF is secret-shared across servers and reconstructed after threshold decryption.
 type IBFVector struct {
-	Chunks   [IBFNChunks][][IBFChunkSize]byte
+	Chunks   [IBFNChunks][]big.Int
 	Counters [IBFNChunks][]uint64
 }
 
@@ -49,7 +48,7 @@ func (v *IBFVector) String() string {
 	for level := range v.Chunks {
 		res += fmt.Sprintf("L%d: ", level)
 		for chunk := range v.Chunks[level] {
-			res += hex.EncodeToString(v.Chunks[level][chunk][:])
+			res += v.Chunks[level][chunk].String()
 			res += fmt.Sprintf(" (%d)", v.Counters[level][chunk])
 			res += "\n"
 		}
@@ -65,7 +64,7 @@ func NewIBFVector(messageSlots uint32) *IBFVector {
 	fac := 1.0
 	for level := range res.Chunks {
 		slotsInLevel := int(float64(messageSlots) * fac)
-		res.Chunks[level] = make([][IBFChunkSize]byte, slotsInLevel)
+		res.Chunks[level] = make([]big.Int, slotsInLevel)
 		res.Counters[level] = make([]uint64, slotsInLevel)
 		fac *= IBFShrinkFactor
 	}
@@ -91,9 +90,7 @@ func (v *IBFVector) InsertChunk(msg [IBFChunkSize]byte) {
 	for level := 0; level < IBFNChunks; level++ {
 		index := ChunkIndex(msg, level, len(v.Chunks[level]))
 
-		currentEl := ChunkToElement(v.Chunks[level][index])
-		crypto.FieldAddInplace(currentEl, msgAsEl, crypto.AuctionFieldOrder)
-		v.Chunks[level][index] = ElementToChunk(currentEl)
+		crypto.FieldAddInplace(&v.Chunks[level][index], msgAsEl, crypto.AuctionFieldOrder)
 		v.Counters[level][index] += 1
 	}
 }
@@ -104,7 +101,7 @@ func (v *IBFVector) EncodeAsFieldElements() []*big.Int {
 	res := []*big.Int{}
 	for level := range v.Chunks {
 		for chunk := range v.Chunks[level] {
-			res = append(res, ChunkToElement(v.Chunks[level][chunk]))
+			res = append(res, new(big.Int).Set(&v.Chunks[level][chunk]))
 		}
 	}
 
@@ -121,7 +118,7 @@ func (v *IBFVector) DecodeFromElements(elements []*big.Int) *IBFVector {
 	index := uint32(0)
 	for level := range v.Chunks {
 		for chunk := range v.Chunks[level] {
-			v.Chunks[level][chunk] = ElementToChunk(elements[index])
+			v.Chunks[level][chunk].Set(elements[index])
 			index += 1
 		}
 	}
@@ -138,6 +135,7 @@ func (v *IBFVector) DecodeFromElements(elements []*big.Int) *IBFVector {
 
 // ChunkIndex computes the bucket index for a chunk at a specific IBF level.
 func ChunkIndex(chunk [IBFChunkSize]byte, level int, itemsInLevel int) uint64 {
+	// TODO: this is really not very fast
 	dataToHash := append([]byte(fmt.Sprintf("%d", level)), chunk[:]...)
 	innerIndexSeed := sha256.Sum256(dataToHash)
 	return uint64(binary.BigEndian.Uint64(innerIndexSeed[0:8])) % uint64(itemsInLevel)
@@ -151,11 +149,11 @@ func (v *IBFVector) Recover() ([][IBFChunkSize]byte, error) {
 
 	// Deep copy chunks and counters
 	for level := range v.Chunks {
-		workingCopy.Chunks[level] = make([][IBFChunkSize]byte, len(v.Chunks[level]))
+		workingCopy.Chunks[level] = make([]big.Int, len(v.Chunks[level]))
 		workingCopy.Counters[level] = make([]uint64, len(v.Counters[level]))
 
 		for i := range v.Chunks[level] {
-			copy(workingCopy.Chunks[level][i][:], v.Chunks[level][i][:])
+			workingCopy.Chunks[level][i].Set(&v.Chunks[level][i])
 			workingCopy.Counters[level][i] = v.Counters[level][i]
 		}
 	}
@@ -166,6 +164,8 @@ func (v *IBFVector) Recover() ([][IBFChunkSize]byte, error) {
 	// Keep track of whether we made progress in the current iteration
 	madeProgress := true
 
+	chunkEl := new(big.Int)
+
 	// Continue peeling until no more progress can be made
 	for madeProgress {
 		madeProgress = false
@@ -176,11 +176,11 @@ func (v *IBFVector) Recover() ([][IBFChunkSize]byte, error) {
 				// Found a pure cell
 				if workingCopy.Counters[level][i] == 1 {
 					// Get the chunk from this cell
-					chunk := workingCopy.Chunks[level][i]
+					chunkEl.Set(&workingCopy.Chunks[level][i])
+					chunk := ElementToChunk(chunkEl)
 
 					// Record this chunk as recovered
 					recovered = append(recovered, chunk)
-					chunkAsEl := ChunkToElement(chunk)
 
 					// Remove this chunk from all levels to continue peeling
 					for innerLevel := range workingCopy.Chunks {
@@ -192,10 +192,7 @@ func (v *IBFVector) Recover() ([][IBFChunkSize]byte, error) {
 						}
 
 						// Remove the chunk from this cell
-						currentEl := ChunkToElement(workingCopy.Chunks[innerLevel][innerIndex])
-						crypto.FieldSubInplace(currentEl, chunkAsEl, crypto.AuctionFieldOrder)
-						workingCopy.Chunks[innerLevel][innerIndex] = ElementToChunk(currentEl)
-
+						crypto.FieldSubInplace(&workingCopy.Chunks[innerLevel][innerIndex], chunkEl, crypto.AuctionFieldOrder)
 						workingCopy.Counters[innerLevel][innerIndex]--
 					}
 
@@ -222,7 +219,7 @@ func (v *IBFVector) Bytes() []byte {
 	res = binary.BigEndian.AppendUint32(res, uint32(len(v.Chunks[0])))
 	for level := range v.Chunks {
 		for chunk := range v.Chunks[level] {
-			res = append(res, v.Chunks[level][chunk][:]...)
+			res = append(res, v.Chunks[level][chunk].Bytes()...)
 		}
 	}
 

blind-auction/ibf_test.go

@@ -14,7 +14,7 @@ func TestIBFVectorRecovery(t *testing.T) {
 	ibf := NewIBFVector(100)
 
 	// Generate a few random chunks to insert
-	chunks := make([][IBFChunkSize]byte, 5)
+	chunks := make([][IBFChunkSize]byte, 20)
 	for i := range chunks {
 		rand.Read(chunks[i][:])
 	}
@@ -26,7 +26,7 @@ func TestIBFVectorRecovery(t *testing.T) {
 
 	// Recover chunks from the IBF
 	recovered, err := ibf.Recover()
-	require.NoError(t, err)
+	require.NoError(t, err, ibf)
 
 	// Verify all chunks were recovered
 	if len(recovered) != len(chunks) {

crypto/fields.go

@@ -4,50 +4,52 @@ import (
 	"math/big"
 )
 
-var prfSeed *big.Int
-
-// MessageFieldOrder defines the finite field order for message operations (513 bits).
+// MessageFieldOrder defines the finite field order for message operations
 var MessageFieldOrder *big.Int
 
-// AuctionFieldOrder defines the finite field order for auction operations (384 bits).
+// AuctionFieldOrder defines the finite field order for auction operations
 var AuctionFieldOrder *big.Int
 
 func init() {
-	// 513 bits so that we can encode 512 bits of data in a chunk
+	// 513 bits so that we can encode 512 bits of data in a chunk for 10k clients, deg(5) and 10 servers
 	MessageFieldOrder, _ = big.NewInt(0).SetString("23551861483160902848625974283278945001376208178765538238759867299042020937974421928051251754596306387970642948144090145836318438166833376091610669188604919", 10)
-	AuctionFieldOrder, _ = big.NewInt(0).SetString("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16) // 384 bits ring
-	prfSeed, _ = big.NewInt(0).SetString("21384347777672109934322149984740494809390049493978212797410708129763158788480720729944469031881574875043683705480707297038846484696174296250022771335208983", 10)
+
+	AuctionFieldOrder, _ = big.NewInt(0).SetString("63275151763513965838163916473346901052322656945674817744137239911918558788929646550175002249326583566310537778017647", 16) // 385 bits prime
 }
 
 // FieldAddInplace performs modular addition in-place: l = (l + r) mod fieldOrder.
 // The result is stored in l and also returned.
-// TODO: bench & optimize
 func FieldAddInplace(l *big.Int, r *big.Int, fieldOrder *big.Int) *big.Int {
 	l.Add(l, r)
-	l.Mod(l, fieldOrder)
+	if l.Cmp(fieldOrder) > 0 {
+		l.Sub(l, fieldOrder)
+	}
+
+	if l.Sign() < 0 {
+		l.Add(l, fieldOrder)
+	}
+
 	/*
-		for l.Cmp(fieldOrder) > 1 {
-			l = l.Sub(l, fieldOrder)
+		if l.Cmp(fieldOrder) > 0 {
+			panic("l + r > 2*field")
 		}
-		for l.Sign() < 0 {
-			l = l.Add(l, fieldOrder)
+		if l.Sign() < 0 {
+			panic("l - r < 2*field")
 		}
 	*/
+
 	return l
 }
 
 // FieldSubInplace performs modular subtraction in-place: l = (l - r) mod fieldOrder.
 // The result is stored in l and also returned.
-// TODO: bench & optimize
 func FieldSubInplace(l *big.Int, r *big.Int, fieldOrder *big.Int) *big.Int {
 	l.Sub(l, r)
-	l.Mod(l, fieldOrder)
-	/*
-		for l.Sign() < 0 {
-			l.Add(l, fieldOrder)
-		}
-		for l.Cmp(fieldOrder) > 1 {
-			l.Sub(l, fieldOrder)
-		}*/
+	if l.Cmp(fieldOrder) > 0 {
+		l.Sub(l, fieldOrder)
+	}
+	if l.Sign() < 0 {
+		l.Add(l, fieldOrder)
+	}
 	return l
 }