Secure multiplication Fx.

bmr/fx.go

@@ -0,0 +1,46 @@
+//
+// Copyright (c) 2024 Markku Rossi
+//
+// All rights reserved.
+//
+
+package bmr
+
+import (
+	"github.com/markkurossi/mpc/ot"
+)
+
+// FxSend implements the sender part of the secure multiplication
+// algorithm Fx (3.1.1 Secure Multiplication - page 7).
+func FxSend(oti ot.OT, a Label) (r Label, err error) {
+	r, err = NewLabel()
+	if err != nil {
+		return
+	}
+
+	x0 := r
+	x1 := r
+	x1.Xor(a)
+
+	wire := ot.Wire{
+		L0: x0.ToOT(),
+		L1: x1.ToOT(),
+	}
+
+	err = oti.Send([]ot.Wire{wire})
+	return
+}
+
+// FxReceive implements the receiver part of the secure multiplication
+// algorithm Fx (3.1.1 Secure Multiplication - page 7).
+func FxReceive(oti ot.OT, bit bool) (xb Label, err error) {
+	flags := []bool{bit}
+	var result [1]ot.Label
+
+	err = oti.Receive(flags, result[:])
+	if err != nil {
+		return
+	}
+	xb.FromOT(result[0])
+	return
+}

bmr/fx_test.go

@@ -0,0 +1,84 @@
+//
+// Copyright (c) 2024 Markku Rossi
+//
+// All rights reserved.
+//
+
+package bmr
+
+import (
+	"testing"
+
+	"github.com/markkurossi/mpc/ot"
+)
+
+func TestFx(t *testing.T) {
+	testFx(t, false)
+	testFx(t, true)
+}
+
+func testFx(t *testing.T, b bool) {
+	fp, tp := ot.NewPipe()
+
+	ch := make(chan interface{})
+
+	go fxReceiver(tp, ch, b)
+
+	oti := ot.NewCO()
+	err := oti.InitSender(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a, err := NewLabel()
+	if err != nil {
+		t.Fatal(err)
+	}
+	r, err := FxSend(oti, a)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ret := <-ch
+	switch xb := ret.(type) {
+	case error:
+		t.Fatal(xb)
+
+	case Label:
+		if b {
+			// b = 1 implies that xb = x1 = r⊕a
+			tst := r
+			tst.Xor(a)
+			if !tst.Equal(xb) {
+				t.Errorf("b=1, got %v, expected %v\n", xb, tst)
+			}
+		} else {
+			// b = 0 implies that xb = x0 = r
+			if !xb.Equal(r) {
+				t.Errorf("b=0: got %v, expected %v\n", xb, r)
+			}
+		}
+
+	default:
+		t.Fatalf("unexpected result: %v(%T)", ret, ret)
+	}
+}
+
+func fxReceiver(pipe ot.IO, ch chan interface{}, bit bool) {
+	defer close(ch)
+
+	oti := ot.NewCO()
+	err := oti.InitReceiver(pipe)
+	if err != nil {
+		ch <- err
+		return
+	}
+
+	xb, err := FxReceive(oti, bit)
+	if err != nil {
+		ch <- err
+		return
+	}
+
+	ch <- xb
+}

bmr/network.go

@@ -0,0 +1,12 @@
+//
+// Copyright (c) 2024 Markku Rossi
+//
+// All rights reserved.
+//
+
+package bmr
+
+// Network protocol messages.
+const (
+	OpFx byte = iota
+)

bmr/wire.go

@@ -1,14 +1,18 @@
 //
-// Copyright (c) 2022 Markku Rossi
+// Copyright (c) 2022-2024 Markku Rossi
 //
 // All rights reserved.
 //
 
 package bmr
 
 import (
+	"bytes"
 	"crypto/rand"
+	"encoding/binary"
 	"fmt"
+
+	"github.com/markkurossi/mpc/ot"
 )
 
 // Wire implements a circuit wire.
@@ -39,9 +43,26 @@ func (l Label) String() string {
 	return fmt.Sprintf("%x", [k / 8]byte(l))
 }
 
+// Equal tests if the label is equal with the argument label.
+func (l Label) Equal(o Label) bool {
+	return bytes.Equal(l[:], o[:])
+}
+
 // Xor sets l to l^o.
 func (l *Label) Xor(o Label) {
 	for i := 0; i < len(l); i++ {
 		l[i] ^= o[i]
 	}
 }
+
+// ToOT converts the label to ot.Label.
+func (l *Label) ToOT() ot.Label {
+	var label ot.Label
+	label.D0 = uint64(binary.BigEndian.Uint32(l[:]))
+	return label
+}
+
+// FromOT sets the label to the ot.Label.
+func (l *Label) FromOT(label ot.Label) {
+	binary.BigEndian.PutUint32(l[:], uint32(label.D0))
+}