1package prover
  2
  3import (
  4	"crypto/rand"
  5	"math"
  6	"math/big"
  7	"runtime"
  8	"sync"
  9
 10	bn256 "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
 11	"github.com/iden3/go-circom-prover-verifier/types"
 12	"github.com/iden3/go-iden3-crypto/utils"
 13)
 14
 15// Proof is the data structure of the Groth16 zkSNARK proof
 16type Proof struct {
 17	A *bn256.G1
 18	B *bn256.G2
 19	C *bn256.G1
 20}
 21
 22// Pk holds the data structure of the ProvingKey
 23type Pk struct {
 24	A          []*bn256.G1
 25	B2         []*bn256.G2
 26	B1         []*bn256.G1
 27	C          []*bn256.G1
 28	NVars      int
 29	NPublic    int
 30	VkAlpha1   *bn256.G1
 31	VkDelta1   *bn256.G1
 32	VkBeta1    *bn256.G1
 33	VkBeta2    *bn256.G2
 34	VkDelta2   *bn256.G2
 35	HExps      []*bn256.G1
 36	DomainSize int
 37	PolsA      []map[int]*big.Int
 38	PolsB      []map[int]*big.Int
 39	PolsC      []map[int]*big.Int
 40}
 41
 42// Witness contains the witness
 43type Witness []*big.Int
 44
 45func randBigInt() (*big.Int, error) {
 46	maxbits := types.R.BitLen()
 47	b := make([]byte, (maxbits/8)-1)
 48	_, err := rand.Read(b)
 49	if err != nil {
 50		return nil, err
 51	}
 52	r := new(big.Int).SetBytes(b)
 53	rq := new(big.Int).Mod(r, types.R)
 54
 55	return rq, nil
 56}
 57
 58// GenerateProof generates the Groth16 zkSNARK proof
 59func GenerateProof(pk *types.Pk, w types.Witness) (*types.Proof, []*big.Int, error) {
 60	var proof types.Proof
 61
 62	r, err := randBigInt()
 63	if err != nil {
 64		return nil, nil, err
 65	}
 66	s, err := randBigInt()
 67	if err != nil {
 68		return nil, nil, err
 69	}
 70
 71	// BEGIN PAR
 72	numcpu := runtime.NumCPU()
 73
 74	proofA := arrayOfZeroesG1(numcpu)
 75	proofB := arrayOfZeroesG2(numcpu)
 76	proofC := arrayOfZeroesG1(numcpu)
 77	proofBG1 := arrayOfZeroesG1(numcpu)
 78	var wg1 sync.WaitGroup
 79	wg1.Add(numcpu)
 80	for _cpu, _ranges := range ranges(pk.NVars, numcpu) {
 81		// split 1
 82		go func(cpu int, ranges [2]int) {
 83			for i := ranges[0]; i < ranges[1]; i++ {
 84				proofA[cpu].Add(proofA[cpu], new(bn256.G1).ScalarMult(pk.A[i], w[i]))
 85				proofB[cpu].Add(proofB[cpu], new(bn256.G2).ScalarMult(pk.B2[i], w[i]))
 86				proofBG1[cpu].Add(proofBG1[cpu], new(bn256.G1).ScalarMult(pk.B1[i], w[i]))
 87				if i >= pk.NPublic+1 {
 88					proofC[cpu].Add(proofC[cpu], new(bn256.G1).ScalarMult(pk.C[i], w[i]))
 89				}
 90			}
 91			wg1.Done()
 92		}(_cpu, _ranges)
 93	}
 94	wg1.Wait()
 95	// join 1
 96	for cpu := 1; cpu < numcpu; cpu++ {
 97		proofA[0].Add(proofA[0], proofA[cpu])
 98		proofB[0].Add(proofB[0], proofB[cpu])
 99		proofC[0].Add(proofC[0], proofC[cpu])
100		proofBG1[0].Add(proofBG1[0], proofBG1[cpu])
101	}
102	proof.A = proofA[0]
103	proof.B = proofB[0]
104	proof.C = proofC[0]
105	// END PAR
106
107	h := calculateH(pk, w)
108
109	proof.A.Add(proof.A, pk.VkAlpha1)
110	proof.A.Add(proof.A, new(bn256.G1).ScalarMult(pk.VkDelta1, r))
111
112	proof.B.Add(proof.B, pk.VkBeta2)
113	proof.B.Add(proof.B, new(bn256.G2).ScalarMult(pk.VkDelta2, s))
114
115	proofBG1[0].Add(proofBG1[0], pk.VkBeta1)
116	proofBG1[0].Add(proofBG1[0], new(bn256.G1).ScalarMult(pk.VkDelta1, s))
117
118	proofC = arrayOfZeroesG1(numcpu)
119	var wg2 sync.WaitGroup
120	wg2.Add(numcpu)
121	for _cpu, _ranges := range ranges(len(h), numcpu) {
122		// split 2
123		go func(cpu int, ranges [2]int) {
124			for i := ranges[0]; i < ranges[1]; i++ {
125				proofC[cpu].Add(proofC[cpu], new(bn256.G1).ScalarMult(pk.HExps[i], h[i]))
126			}
127			wg2.Done()
128		}(_cpu, _ranges)
129	}
130	wg2.Wait()
131	// join 2
132	for cpu := 1; cpu < numcpu; cpu++ {
133		proofC[0].Add(proofC[0], proofC[cpu])
134	}
135	proof.C.Add(proof.C, proofC[0])
136
137	proof.C.Add(proof.C, new(bn256.G1).ScalarMult(proof.A, s))
138	proof.C.Add(proof.C, new(bn256.G1).ScalarMult(proofBG1[0], r))
139	rsneg := new(big.Int).Mod(new(big.Int).Neg(new(big.Int).Mul(r, s)), types.R)
140	proof.C.Add(proof.C, new(bn256.G1).ScalarMult(pk.VkDelta1, rsneg))
141
142	pubSignals := w[1 : pk.NPublic+1]
143
144	return &proof, pubSignals, nil
145}
146
147func calculateH(pk *types.Pk, w types.Witness) []*big.Int {
148	m := pk.DomainSize
149	polAT := arrayOfZeroes(m)
150	polBT := arrayOfZeroes(m)
151
152	numcpu := runtime.NumCPU()
153
154	var wg1 sync.WaitGroup
155	wg1.Add(2)
156	go func() {
157		for i := 0; i < pk.NVars; i++ {
158			for j := range pk.PolsA[i] {
159				polAT[j] = fAdd(polAT[j], fMul(w[i], pk.PolsA[i][j]))
160			}
161		}
162		wg1.Done()
163	}()
164	go func() {
165		for i := 0; i < pk.NVars; i++ {
166			for j := range pk.PolsB[i] {
167				polBT[j] = fAdd(polBT[j], fMul(w[i], pk.PolsB[i][j]))
168			}
169		}
170		wg1.Done()
171	}()
172	wg1.Wait()
173	polATe := utils.BigIntArrayToElementArray(polAT)
174	polBTe := utils.BigIntArrayToElementArray(polBT)
175
176	polASe := ifft(polATe)
177	polBSe := ifft(polBTe)
178
179	r := int(math.Log2(float64(m))) + 1
180	roots := newRootsT()
181	roots.setRoots(r)
182
183	var wg2 sync.WaitGroup
184	wg2.Add(numcpu)
185	for _cpu, _ranges := range ranges(len(polASe), numcpu) {
186		go func(cpu int, ranges [2]int) {
187			for i := ranges[0]; i < ranges[1]; i++ {
188				polASe[i].Mul(polASe[i], roots.roots[r][i])
189				polBSe[i].Mul(polBSe[i], roots.roots[r][i])
190			}
191			wg2.Done()
192		}(_cpu, _ranges)
193	}
194	wg2.Wait()
195
196	polATodd := fft(polASe)
197	polBTodd := fft(polBSe)
198
199	polABT := arrayOfZeroesE(len(polASe) * 2)
200	var wg3 sync.WaitGroup
201	wg3.Add(numcpu)
202	for _cpu, _ranges := range ranges(len(polASe), numcpu) {
203		go func(cpu int, ranges [2]int) {
204			for i := ranges[0]; i < ranges[1]; i++ {
205				polABT[2*i].Mul(polATe[i], polBTe[i])
206				polABT[2*i+1].Mul(polATodd[i], polBTodd[i])
207			}
208			wg3.Done()
209		}(_cpu, _ranges)
210	}
211	wg3.Wait()
212
213	hSeFull := ifft(polABT)
214
215	hSe := hSeFull[m:]
216	return utils.ElementArrayToBigIntArray(hSe)
217}
218
219func ranges(n, parts int) [][2]int {
220	s := make([][2]int, parts)
221	p := float64(n) / float64(parts)
222	for i := 0; i < parts; i++ {
223		a, b := int(float64(i)*p), int(float64(i+1)*p)
224		s[i] = [2]int{a, b}
225	}
226	return s
227}