smeb_y/ceremonyclient
1
0
Fork 0
mirror of https://source.quilibrium.com/quilibrium/ceremonyclient.git synced 2024-12-27 00:55:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
release-non-datacenter
ceremonyclient/node/crypto/shuffle/matrix_test.go

537 lines
19 KiB
Go
Raw Permalink Normal View History

v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
package shuffle_test
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
import (
"fmt"
"math/big"
"testing"
"filippo.io/edwards25519"
"github.com/stretchr/testify/assert"
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/crypto/shuffle"
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
)
func TestGeneratePermutationMatrix(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
m := shuffle.GeneratePermutationMatrix(6)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
for _, x := range m {
ySum := byte(0x00)
for _, y := range x {
ySum += y.Bytes()[0]
}
assert.Equal(t, ySum, byte(0x01))
}
for x := 0; x < len(m); x++ {
xSum := byte(0x00)
for y := 0; y < len(m); y++ {
xSum += m[y][x].Bytes()[0]
}
assert.Equal(t, xSum, byte(0x01))
}
}
func verifyLagrange(t *testing.T, shares []*edwards25519.Scalar, expected *edwards25519.Scalar, total, threshold int) {
var result *edwards25519.Scalar
for i := 1; i <= total-threshold+1; i++ {
var reconstructedSum *edwards25519.Scalar
for j := 0; j < threshold; j++ {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
oneLENumBytes := shuffle.BigIntToLEBytes(big.NewInt(1))
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
coeffNum, _ := edwards25519.NewScalar().SetCanonicalBytes(oneLENumBytes)
coeffDenom, _ := edwards25519.NewScalar().SetCanonicalBytes(oneLENumBytes)
for k := 0; k < threshold; k++ {
if j != k {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
ikBytes := shuffle.BigIntToLEBytes(big.NewInt(int64(i + k)))
ijBytes := shuffle.BigIntToLEBytes(big.NewInt(int64(i + j)))
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
ikScalar, _ := edwards25519.NewScalar().SetCanonicalBytes(ikBytes)
ijScalar, _ := edwards25519.NewScalar().SetCanonicalBytes(ijBytes)
coeffNum.Multiply(coeffNum, ikScalar)
ikScalar.Subtract(ikScalar, ijScalar)
coeffDenom.Multiply(coeffDenom, ikScalar)
}
}
coeffDenom.Invert(coeffDenom)
coeffNum.Multiply(coeffNum, coeffDenom)
reconstructedFrag := edwards25519.NewScalar().Multiply(coeffNum, shares[i+j-1])
if reconstructedSum == nil {
reconstructedSum = reconstructedFrag
} else {
reconstructedSum.Add(reconstructedSum, reconstructedFrag)
}
}
if result == nil {
result = reconstructedSum
assert.Equal(t, expected.Bytes(), result.Bytes())
} else if result.Equal(reconstructedSum) == 0 {
fmt.Println("mismatched reconstruction")
t.FailNow()
}
}
}
func TestGenerateShamirMatrix(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
m := shuffle.GeneratePermutationMatrix(6)
sm := shuffle.ShamirSplitMatrix(m, 10, 3)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
for xi, x := range sm {
for yi, y := range x {
verifyLagrange(t, y, m[xi][yi], 10, 3)
}
}
}
func TestMatrixDotProduct(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
zeroBytes := shuffle.BigIntToLEBytes(big.NewInt(0))
oneBytes := shuffle.BigIntToLEBytes(big.NewInt(1))
twoBytes := shuffle.BigIntToLEBytes(big.NewInt(2))
threeBytes := shuffle.BigIntToLEBytes(big.NewInt(3))
fourBytes := shuffle.BigIntToLEBytes(big.NewInt(4))
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
zero, _ := edwards25519.NewScalar().SetCanonicalBytes(zeroBytes)
one, _ := edwards25519.NewScalar().SetCanonicalBytes(oneBytes)
two, _ := edwards25519.NewScalar().SetCanonicalBytes(twoBytes)
three, _ := edwards25519.NewScalar().SetCanonicalBytes(threeBytes)
four, _ := edwards25519.NewScalar().SetCanonicalBytes(fourBytes)
aMatrix := [][]*edwards25519.Scalar{
{two, two},
{zero, three},
{zero, four},
}
bMatrix := [][]*edwards25519.Scalar{
{two, one, two},
{three, two, four},
}
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
abMatrix := shuffle.GenerateDotProduct(aMatrix, bMatrix)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
assert.Equal(t, byte(0x0a), abMatrix[0][0].Bytes()[0])
assert.Equal(t, byte(0x06), abMatrix[0][1].Bytes()[0])
assert.Equal(t, byte(0x0c), abMatrix[0][2].Bytes()[0])
assert.Equal(t, byte(0x09), abMatrix[1][0].Bytes()[0])
assert.Equal(t, byte(0x06), abMatrix[1][1].Bytes()[0])
assert.Equal(t, byte(0x0c), abMatrix[1][2].Bytes()[0])
assert.Equal(t, byte(0x0c), abMatrix[2][0].Bytes()[0])
assert.Equal(t, byte(0x08), abMatrix[2][1].Bytes()[0])
assert.Equal(t, byte(0x10), abMatrix[2][2].Bytes()[0])
}
func TestGenerateRandomBeaverTripleMatrixShares(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
beaverTripleShares := shuffle.GenerateRandomBeaverTripleMatrixShares(6, 10, 3)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
uMatrixShares := beaverTripleShares[0]
vMatrixShares := beaverTripleShares[1]
uvMatrixShares := beaverTripleShares[2]
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
uMatrix := shuffle.InterpolateMatrixShares(uMatrixShares, []int{1, 2, 3})
vMatrix := shuffle.InterpolateMatrixShares(vMatrixShares, []int{1, 2, 3})
uvMatrix := shuffle.InterpolateMatrixShares(uvMatrixShares, []int{1, 2, 3})
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
for x := 0; x < len(uMatrixShares); x++ {
for y := 0; y < len(uMatrixShares[0]); y++ {
verifyLagrange(t, uMatrixShares[x][y], uMatrix[x][y], 10, 3)
verifyLagrange(t, vMatrixShares[x][y], vMatrix[x][y], 10, 3)
verifyLagrange(t, uvMatrixShares[x][y], uvMatrix[x][y], 10, 3)
}
}
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
uvCheck := shuffle.GenerateDotProduct(uMatrix, vMatrix)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
assert.Equal(t, uvMatrix, uvCheck)
}
func TestPermutationMatrix(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
permutationMatrix1 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix2 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix3 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix4 := shuffle.GeneratePermutationMatrix(6)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
permutationMatrix := shuffle.GenerateDotProduct(permutationMatrix1, permutationMatrix2)
permutationMatrix = shuffle.GenerateDotProduct(permutationMatrix, permutationMatrix3)
permutationMatrix = shuffle.GenerateDotProduct(permutationMatrix, permutationMatrix4)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
one, _ := edwards25519.NewScalar().SetCanonicalBytes(shuffle.BigIntToLEBytes(big.NewInt(1)))
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
for x := 0; x < 6; x++ {
sumX := edwards25519.NewScalar()
for y := 0; y < 6; y++ {
sumX.Add(sumX, permutationMatrix[x][y])
}
assert.Equal(t, sumX, one)
}
for y := 0; y < 6; y++ {
sumY := edwards25519.NewScalar()
for x := 0; x < 6; x++ {
sumY.Add(sumY, permutationMatrix[x][y])
}
assert.Equal(t, sumY, one)
}
}
func TestPermutationSharing(t *testing.T) {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
permutationMatrix1 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix2 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix3 := shuffle.GeneratePermutationMatrix(6)
permutationMatrix4 := shuffle.GeneratePermutationMatrix(6)
permutationMatrixShares1 := shuffle.ShamirSplitMatrix(permutationMatrix1, 4, 3)
permutationMatrixShares2 := shuffle.ShamirSplitMatrix(permutationMatrix2, 4, 3)
permutationMatrixShares3 := shuffle.ShamirSplitMatrix(permutationMatrix3, 4, 3)
permutationMatrixShares4 := shuffle.ShamirSplitMatrix(permutationMatrix4, 4, 3)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
inverseShareMatrix1 := make([][][]*edwards25519.Scalar, 4)
inverseShareMatrix2 := make([][][]*edwards25519.Scalar, 4)
inverseShareMatrix3 := make([][][]*edwards25519.Scalar, 4)
inverseShareMatrix4 := make([][][]*edwards25519.Scalar, 4)
for i := 0; i < 4; i++ {
inverseShareMatrix1[i] = make([][]*edwards25519.Scalar, 6)
inverseShareMatrix2[i] = make([][]*edwards25519.Scalar, 6)
inverseShareMatrix3[i] = make([][]*edwards25519.Scalar, 6)
inverseShareMatrix4[i] = make([][]*edwards25519.Scalar, 6)
for x := 0; x < 6; x++ {
inverseShareMatrix1[i][x] = make([]*edwards25519.Scalar, 6)
inverseShareMatrix2[i][x] = make([]*edwards25519.Scalar, 6)
inverseShareMatrix3[i][x] = make([]*edwards25519.Scalar, 6)
inverseShareMatrix4[i][x] = make([]*edwards25519.Scalar, 6)
for y := 0; y < 6; y++ {
inverseShareMatrix1[i][x][y] = permutationMatrixShares1[x][y][i]
inverseShareMatrix2[i][x][y] = permutationMatrixShares2[x][y][i]
inverseShareMatrix3[i][x][y] = permutationMatrixShares3[x][y][i]
inverseShareMatrix4[i][x][y] = permutationMatrixShares4[x][y][i]
}
}
}
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
beaverTripleShares1 := shuffle.GenerateRandomBeaverTripleMatrixShares(6, 4, 3)
beaverTripleShares2 := shuffle.GenerateRandomBeaverTripleMatrixShares(6, 4, 3)
beaverTripleShares3 := shuffle.GenerateRandomBeaverTripleMatrixShares(6, 4, 3)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
beaverTriplesAShares1 := beaverTripleShares1[0]
beaverTriplesBShares1 := beaverTripleShares1[1]
beaverTriplesABShares1 := beaverTripleShares1[2]
beaverTriplesAShares2 := beaverTripleShares2[0]
beaverTriplesBShares2 := beaverTripleShares2[1]
beaverTriplesABShares2 := beaverTripleShares2[2]
beaverTriplesAShares3 := beaverTripleShares3[0]
beaverTriplesBShares3 := beaverTripleShares3[1]
beaverTriplesABShares3 := beaverTripleShares3[2]
inverseBeaverTriplesAShares1 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesBShares1 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesABShares1 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesAShares2 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesBShares2 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesABShares2 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesAShares3 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesBShares3 := make([][][]*edwards25519.Scalar, 4)
inverseBeaverTriplesABShares3 := make([][][]*edwards25519.Scalar, 4)
for i := 0; i < 4; i++ {
inverseBeaverTriplesAShares1[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares1[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares1[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesAShares2[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares2[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares2[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesAShares3[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares3[i] = make([][]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares3[i] = make([][]*edwards25519.Scalar, 6)
for x := 0; x < 6; x++ {
inverseBeaverTriplesAShares1[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares1[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares1[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesAShares2[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares2[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares2[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesAShares3[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesBShares3[i][x] = make([]*edwards25519.Scalar, 6)
inverseBeaverTriplesABShares3[i][x] = make([]*edwards25519.Scalar, 6)
for y := 0; y < 6; y++ {
inverseBeaverTriplesAShares1[i][x][y] = beaverTriplesAShares1[x][y][i]
inverseBeaverTriplesBShares1[i][x][y] = beaverTriplesBShares1[x][y][i]
inverseBeaverTriplesABShares1[i][x][y] = beaverTriplesABShares1[x][y][i]
inverseBeaverTriplesAShares2[i][x][y] = beaverTriplesAShares2[x][y][i]
inverseBeaverTriplesBShares2[i][x][y] = beaverTriplesBShares2[x][y][i]
inverseBeaverTriplesABShares2[i][x][y] = beaverTriplesABShares2[x][y][i]
inverseBeaverTriplesAShares3[i][x][y] = beaverTriplesAShares3[x][y][i]
inverseBeaverTriplesBShares3[i][x][y] = beaverTriplesBShares3[x][y][i]
inverseBeaverTriplesABShares3[i][x][y] = beaverTriplesABShares3[x][y][i]
}
}
}
es1 := make([][][]*edwards25519.Scalar, 6)
fs1 := make([][][]*edwards25519.Scalar, 6)
es2 := make([][][]*edwards25519.Scalar, 6)
fs2 := make([][][]*edwards25519.Scalar, 6)
es3 := make([][][]*edwards25519.Scalar, 6)
fs3 := make([][][]*edwards25519.Scalar, 6)
for x := 0; x < 6; x++ {
es1[x] = make([][]*edwards25519.Scalar, 6)
fs1[x] = make([][]*edwards25519.Scalar, 6)
es2[x] = make([][]*edwards25519.Scalar, 6)
fs2[x] = make([][]*edwards25519.Scalar, 6)
es3[x] = make([][]*edwards25519.Scalar, 6)
fs3[x] = make([][]*edwards25519.Scalar, 6)
for y := 0; y < 6; y++ {
es1[x][y] = make([]*edwards25519.Scalar, 4)
fs1[x][y] = make([]*edwards25519.Scalar, 4)
es2[x][y] = make([]*edwards25519.Scalar, 4)
fs2[x][y] = make([]*edwards25519.Scalar, 4)
es3[x][y] = make([]*edwards25519.Scalar, 4)
fs3[x][y] = make([]*edwards25519.Scalar, 4)
for i := 0; i < 4; i++ {
es1[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix1[i][x][y], inverseBeaverTriplesAShares1[i][x][y])
fs1[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix2[i][x][y], inverseBeaverTriplesBShares1[i][x][y])
es2[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix2[i][x][y], inverseBeaverTriplesAShares2[i][x][y])
fs2[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix3[i][x][y], inverseBeaverTriplesBShares2[i][x][y])
es3[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix3[i][x][y], inverseBeaverTriplesAShares3[i][x][y])
fs3[x][y][i] = edwards25519.NewScalar().Subtract(inverseShareMatrix4[i][x][y], inverseBeaverTriplesBShares3[i][x][y])
}
}
}
// e = a - u
// f = b - v
// (a - u)(b - v) = -ab + ub + av - uv + (ab-av) + (ab - ub) + uv
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
e1 := shuffle.InterpolateMatrixShares(es1, []int{1, 2, 3, 4})
f1 := shuffle.InterpolateMatrixShares(fs1, []int{1, 2, 3, 4})
e2 := shuffle.InterpolateMatrixShares(es2, []int{1, 2, 3, 4})
f2 := shuffle.InterpolateMatrixShares(fs2, []int{1, 2, 3, 4})
e3 := shuffle.InterpolateMatrixShares(es3, []int{1, 2, 3, 4})
f3 := shuffle.InterpolateMatrixShares(fs3, []int{1, 2, 3, 4})
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
// mul(a, b) => <e> = <a> - <u>, <f> = <b> - <v>, <c> = -i * e * f + f * <a> + e * <b> + <z>
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
ef1 := shuffle.GenerateDotProduct(e1, f1)
ef2 := shuffle.GenerateDotProduct(e2, f2)
ef3 := shuffle.GenerateDotProduct(e3, f3)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
fa1 := make([][][]*edwards25519.Scalar, 4)
fa2 := make([][][]*edwards25519.Scalar, 4)
fa3 := make([][][]*edwards25519.Scalar, 4)
eb1 := make([][][]*edwards25519.Scalar, 4)
eb2 := make([][][]*edwards25519.Scalar, 4)
eb3 := make([][][]*edwards25519.Scalar, 4)
cs1 := make([][][]*edwards25519.Scalar, 4)
cs2 := make([][][]*edwards25519.Scalar, 4)
cs3 := make([][][]*edwards25519.Scalar, 4)
// cs := make([][][]*edwards25519.Scalar, 4)
inverseCS1 := make([][][]*edwards25519.Scalar, 6)
inverseCS3 := make([][][]*edwards25519.Scalar, 6)
for i := 0; i < 4; i++ {
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
fa1[i] = shuffle.GenerateDotProduct(inverseShareMatrix1[i], f1)
eb1[i] = shuffle.GenerateDotProduct(e1, inverseShareMatrix2[i])
fa2[i] = shuffle.GenerateDotProduct(inverseShareMatrix2[i], f2)
eb2[i] = shuffle.GenerateDotProduct(e2, inverseShareMatrix3[i])
fa3[i] = shuffle.GenerateDotProduct(inverseShareMatrix3[i], f3)
eb3[i] = shuffle.GenerateDotProduct(e3, inverseShareMatrix4[i])
cs1[i] = shuffle.AddMatrices(shuffle.ScalarMult(-1, ef1), fa1[i], eb1[i], inverseBeaverTriplesABShares1[i])
cs2[i] = shuffle.AddMatrices(shuffle.ScalarMult(-1, ef2), fa2[i], eb2[i], inverseBeaverTriplesABShares2[i])
cs3[i] = shuffle.AddMatrices(shuffle.ScalarMult(-1, ef3), fa3[i], eb3[i], inverseBeaverTriplesABShares3[i])
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
}
for x := 0; x < 6; x++ {
inverseCS1[x] = make([][]*edwards25519.Scalar, 6)
inverseCS3[x] = make([][]*edwards25519.Scalar, 6)
for y := 0; y < 6; y++ {
inverseCS1[x][y] = make([]*edwards25519.Scalar, 4)
inverseCS3[x][y] = make([]*edwards25519.Scalar, 4)
for i := 0; i < 4; i++ {
inverseCS1[x][y][i] = cs1[i][x][y]
inverseCS3[x][y][i] = cs3[i][x][y]
}
}
}
v1.2.4 (#43)
2024-02-13 07:04:56 +00:00
c1 := shuffle.InterpolateMatrixShares(inverseCS1, []int{1, 2, 3, 4})
c3 := shuffle.InterpolateMatrixShares(inverseCS3, []int{1, 2, 3, 4})
c := shuffle.GenerateDotProduct(c1, c3)
ab := shuffle.GenerateDotProduct(permutationMatrix1, permutationMatrix2)
abc := shuffle.GenerateDotProduct(ab, permutationMatrix3)
abcd := shuffle.GenerateDotProduct(abc, permutationMatrix4)
Launch readiness: import utility
2023-08-21 03:50:38 +00:00
for x := 0; x < 6; x++ {
for y := 0; y < 6; y++ {
assert.ElementsMatch(t, c[x][y].Bytes(), abcd[x][y].Bytes())
}
}
}
// func TestIlanBeaverMultiMatrixSharing(t *testing.T) {
// fmt.Println("start")
// start := time.Now()
// ri := [65][][][]*edwards25519.Scalar{}
// rj := [65][][][]*edwards25519.Scalar{}
// next := time.Now()
// diff := next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("generating random and inverse matrices")
// var wg sync.WaitGroup
// for i := 0; i <= 64; i++ {
// wg.Add(1)
// i := i
// go func() {
// defer wg.Done()
// rs := crypto.GenerateRandomMatrixAndInverseShares(80, 4, 3)
// ri[i] = make([][][]*edwards25519.Scalar, 4)
// rj[i] = make([][][]*edwards25519.Scalar, 4)
// for j := 0; j < 4; j++ {
// ri[i][j] = make([][]*edwards25519.Scalar, 80)
// rj[i][j] = make([][]*edwards25519.Scalar, 80)
// for x := 0; x < 80; x++ {
// ri[i][j][x] = make([]*edwards25519.Scalar, 80)
// rj[i][j][x] = make([]*edwards25519.Scalar, 80)
// for y := 0; y < 80; y++ {
// ri[i][j][x][y] = rs[0][x][y][j]
// rj[i][j][x][y] = rs[1][x][y][j]
// }
// }
// }
// }()
// }
// wg.Wait()
// next = time.Now()
// diff = next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("generating permutation matrices")
// rxr := [64][][][]*edwards25519.Scalar{}
// for i := 1; i <= 64; i++ {
// wg.Add(1)
// i := i
// go func() {
// defer wg.Done()
// x := crypto.GeneratePermutationMatrix(80)
// xs := crypto.ShamirSplitMatrix(x, 4, 3)
// ixs := make([][][]*edwards25519.Scalar, 4)
// rxr[i-1] = make([][][]*edwards25519.Scalar, 4)
// for j := 0; j < 4; j++ {
// ixs[j] = make([][]*edwards25519.Scalar, 80)
// rxr[i-1][j] = make([][]*edwards25519.Scalar, 80)
// for x := 0; x < 80; x++ {
// ixs[j][x] = make([]*edwards25519.Scalar, 80)
// rxr[i-1][j][x] = make([]*edwards25519.Scalar, 80)
// for y := 0; y < 80; y++ {
// ixs[j][x][y] = xs[x][y][j]
// }
// }
// }
// for j := 0; j < 4; j++ {
// rxrij := crypto.GenerateDotProduct(ri[i-1][j], ixs[j])
// rxr[i-1][j] = crypto.GenerateDotProduct(rxrij, rj[i][j])
// }
// }()
// }
// wg.Wait()
// next = time.Now()
// diff = next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("swapping elements for interpolation")
// irxr := [64][][][]*edwards25519.Scalar{}
// for i := 0; i < 64; i++ {
// wg.Add(1)
// i := i
// go func() {
// defer wg.Done()
// irxr[i] = make([][][]*edwards25519.Scalar, 80)
// for x := 0; x < 80; x++ {
// irxr[i][x] = make([][]*edwards25519.Scalar, 80)
// for y := 0; y < 80; y++ {
// irxr[i][x][y] = make([]*edwards25519.Scalar, 4)
// for j := 0; j < 4; j++ {
// irxr[i][x][y][j] = rxr[i][j][x][y]
// }
// }
// }
// }()
// }
// wg.Wait()
// rxri := [][]*edwards25519.Scalar{}
// next = time.Now()
// diff = next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("interpolating")
// for i := 0; i < 64; i++ {
// next := crypto.InterpolateMatrixShares(irxr[i], []int{1, 2, 3})
// if i == 0 {
// rxri = next
// } else {
// rxri = crypto.GenerateDotProduct(rxri, next)
// }
// }
// rpms := make([][][]*edwards25519.Scalar, 4)
// next = time.Now()
// diff = next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("generating intermediary dot products")
// for i := 1; i <= 4; i++ {
// rpms[i-1] = crypto.GenerateDotProduct(crypto.GenerateDotProduct(rj[0][i-1], rxri), ri[64][i-1])
// }
// final := make([][][]*edwards25519.Scalar, 80)
// for x := 0; x < 80; x++ {
// final[x] = make([][]*edwards25519.Scalar, 80)
// for y := 0; y < 80; y++ {
// final[x][y] = make([]*edwards25519.Scalar, 4)
// for j := 0; j < 4; j++ {
// final[x][y][j] = rpms[j][x][y]
// }
// }
// }
// next = time.Now()
// diff = next.Sub(start)
// fmt.Println(diff)
// start = next
// fmt.Println("final interpolation")
// rpm := crypto.InterpolateMatrixShares(final, []int{1, 2, 3})
// for x := 0; x < 80; x++ {
// for y := 0; y < 80; y++ {
// fmt.Printf("%x, ", rpm[x][y].Bytes()[0])
// }
// fmt.Println()
// }
// t.Fail()
// }
Reference in New Issue Copy Permalink