circuit.go

package garbled

import (
	"bytes"
	cryptoUtil "crycomp/internal/crypto/util"
	"crycomp/internal/util"
	"crypto/sha256"
)

type Circuit struct {
	numInputs, numWires, k int

	G func(a, b []byte, i int) []byte

	F *Table
	E []*Table
	D *Table
}

func NewCircuit(numInputs, numWires, k int) (c *Circuit, err error) {
	F, err := NewTable(numWires-numInputs, 4, k*2)
	if err != nil {
		return
	}
	c = &Circuit{
		numInputs: numInputs,
		numWires:  numWires,
		k:         k,

		F: F,
	}
	return
}

func (c *Circuit) GarbleBloodCircuit() (err error) {
	// 1. Create two random strings for each wire.
	kTable, err := NewTable(c.numWires, 2, c.k)
	if err != nil {
		return
	}
	err = kTable.randomizeTable()
	if err != nil {
		return
	}

	// 2. Create a garbled table for all F values (4 for each gate)
	c.F.setRow(0, c.garbleGate(kTable, 0, 3, 6, ORGateWithNot))
	c.F.setRow(1, c.garbleGate(kTable, 1, 4, 7, ORGateWithNot))
	c.F.setRow(2, c.garbleGate(kTable, 2, 5, 8, ORGateWithNot))

	c.F.setRow(3, c.garbleGate(kTable, 6, 7, 9, ANDGate))
	c.F.setRow(4, c.garbleGate(kTable, 8, 9, 10, ANDGate))

	// Create e
	c.E = make([]*Table, 2)
	c.E[0], _ = NewTable(c.numInputs, 2, c.k)
	c.E[0].SetData(kTable.getRows(0, c.numInputs))

	c.E[1], _ = NewTable(c.numInputs, 2, c.k)
	c.E[1].SetData(kTable.getRows(c.numInputs, c.numInputs))

	// Create d
	c.D, _ = NewTable(1, 2, c.k)
	c.D.SetData(kTable.getRow(c.numWires - 1))

	return
}

// Encode x using the e table. If ey == true, we use the second
// half of e, otherwise first half
func Encode(e *Table, x []bool) (X []byte) {
	X = make([]byte, 0)
	for i, b := range x {
		if b {
			X = append(X, e.getValue(i, 1)...)
		} else {
			X = append(X, e.getValue(i, 0)...)
		}
	}
	if len(x)*e.valueLen != len(X) {
		panic("Wrong length of X")
	}
	return
}

//Creates a row (C_0^i, C_1^i, C_2^i ,C_3^i) for the garbled table, where
func (c *Circuit) garbleGate(K *Table, Li, Ri, out int, gateFun func(a, b int) int) []byte {
	cRow := make([]byte, K.valueLen*8) // because 4 values of double length
	perm := cryptoUtil.Perm(4)         // Random permutation

	// for (a,b) in {0,1} x {0,1}
	for a := 0; a <= 1; a++ {
		for b := 0; b <= 1; b++ {
			left := c.G(K.getValue(Li, a), K.getValue(Ri, b), out)
			right := make([]byte, K.valueLen*2)

			copy(right[:K.valueLen], K.getValue(out, gateFun(a, b)))

			// The index to write this value to. This depends in the row permutation.
			rowI := perm[a*2+b] * K.valueLen
			util.XOR(left, left, right) // XOR with left as destination.
			copy(cRow[rowI:rowI+K.valueLen], left)
		}
	}
	return cRow
}

func G(A, B []byte, i int) []byte {
	hash := sha256.New()
	hash.Write(A)
	hash.Write(B)
	hash.Write([]byte{byte(i)})
	return hash.Sum(nil)
}

func Evaluate(F *Table, x []byte) ([]byte, error) {
	K, err := NewTable(1, len(x)/F.valueLen, F.valueLen*8)
	if err != nil {
		return nil, err
	}
	K.SetData(x)

	// For each circuit gate
	for i := 0; i < len(F.data); i++ {
		// For each C
		for j := 0; j < 4; j++ {
			// dst := make([]byte, 2*F.valueLen)
			// util.XOR(dst, K.getValue())
		}
	}

	// var K = x
	// var res []byte
	// for i := 0; i < 3; i++ {
	// 	for j := 0; j < 4; j++ {
	// 		// res = util.XOR(G(K[i], K[i+3], i), C.GetValueOld(i, j))
	// 		if bytes.Equal(res[16:], make([]byte, 16)) {
	// 			K = append(K, res[:16])
	// 			break
	// 		}
	// 	}
	// 	return nil, fmt.Errorf("Aborted while evaluating the garbled circuit, no match was found")
	// }
	// return K[len(K)-1], nil
	return nil, nil
}

func Decode(d [][]byte, Z []byte) bool {
	if bytes.Equal(d[0], Z) {
		return false
	} else if bytes.Equal(d[1], Z) {
		return true
	}
	//TODO: Error handling
	return false
}

////////////////////////////////////////////////////////////////
// Circuit
////////////////////////////////////////////////////////////////

// type Circuit struct {
// 	wires      []int
// 	gates      []Gate
// 	outputWire int
// 	numInput   int
// }

// func NewCircuit(numInput int) *Circuit {
// 	return &Circuit{
// 		wires:    make([]int, numInput),
// 		gates:    make([]Gate, 0),
// 		numInput: numInput,
// 	}
// }

// func (c *Circuit) getInputWires(i int) (Li, Ri int) {
// 	return i, c.numInput + i
// }

// func (c *Circuit) AddGate(Li, Ri int, f func(a, b int) int) *Gate {
// 	c.wires = append(c.wires, 0)
// 	g := newGate(Li, Ri, len(c.wires)-1, f)
// 	c.gates = append(c.gates, *g)
// 	return g
// }

// type Gate struct {
// 	Li, Ri    int
// 	i         int
// 	truthfunc func(a, b int) int
// }

// func newGate(Li, Ri, i int, f func(a, b int) int) (g *Gate) {
// 	g.Li = Li
// 	g.Ri = Ri
// 	g.i = i
// 	g.truthfunc = f
// 	return
// }

////////////////////////////////////////////////////////////////
// GATES
////////////////////////////////////////////////////////////////

func ORGate(a, b int) int {
	if a+b != 0 {
		return 1
	} else {
		return 0
	}
}

func ORGateWithNot(a, b int) int {
	if ((1 - b) + a) == 0 {
		return 0
	} else {
		return 1
	}
}

func ANDGate(a, b int) int {
	return a * b
}