gnark-plonky2-verifier/ed25519.go
ed25519.goRaw
1// Copyright 2020 ConsenSys AG
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package main
16
17import (
18 "fmt"
19 "gnark-ed25519/poseidon"
20 "math/big"
21 "time"
22
23 "github.com/consensys/gnark-crypto/ecc"
24 "github.com/consensys/gnark/backend/groth16"
25 "github.com/consensys/gnark/frontend"
26 "github.com/consensys/gnark/frontend/cs/r1cs"
27 "github.com/consensys/gnark/test"
28)
29
30// type Eddsa25519Circuit struct {
31// M []frontend.Variable
32// Pk []frontend.Variable
33// Sig []frontend.Variable
34// }
35
36// func (circuit *Eddsa25519Circuit) Define(api frontend.API) error {
37// c, err := edwards_curve.New[edwards_curve.Ed25519, edwards_curve.Ed25519Scalars](api)
38// if err != nil {
39// return err
40// }
41// edwards_curve.CheckValid(c, circuit.Sig, circuit.M, circuit.Pk)
42// return nil
43// }
44
45// type Sha512Circuit struct {
46// in []frontend.Variable `gnark:"in"`
47// out []frontend.Variable `gnark:"out"`
48// }
49
50// func (circuit *Sha512Circuit) Define(api frontend.API) error {
51// res := sha512.Sha512(api, circuit.in)
52// if len(res) != 512 {
53// panic("bad length")
54// }
55// for i := 0; i < 512; i++ {
56// api.AssertIsEqual(res[i], circuit.out[i])
57// }
58// return nil
59// }
60
61// func main() {
62// err := mainImpl()
63// if err != nil {
64// fmt.Println(err)
65// os.Exit(1)
66// }
67// }
68
69// // func mainImpl() error {
70// // in := bytesToBits([]byte("Succinct Labs"))
71// // out := hexToBits("503ace098aa03f6feec1b5df0a38aee923f744a775508bc81f2b94ad139be297c2e8cd8c44af527b5d3f017a7fc929892c896604047e52e3f518924f52bff0dc")
72
73// // myCircuit := Sha512Circuit{
74// // in,
75// // out,
76// // }
77// // fmt.Println(time.Now(), "compiling...")
78// // r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &myCircuit)
79// // if err != nil {
80// // return err
81// // }
82
83// // assignment := &Sha512Circuit{
84// // in,
85// // out,
86// // }
87// // fmt.Println(time.Now(), "generating witness...")
88// // witness, _ := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
89// // publicWitness, _ := witness.Public()
90// // fmt.Println(time.Now(), "groth setup...")
91// // pk, vk, err := groth16.Setup(r1cs)
92// // fmt.Println(time.Now(), "groth prove...")
93// // proof, err := groth16.Prove(r1cs, pk, witness)
94// // fmt.Println(time.Now(), "groth verify...")
95// // err = groth16.Verify(proof, vk, publicWitness)
96// // if err != nil {
97// // return err
98// // }
99// // fmt.Println(proof)
100// // return nil
101// // }
102
103// func mainImpl() error {
104// M := "53756363696e6374204c616273"
105// Pk := "f7ec1c43f4de9d49556de87b86b26a98942cb078486fdb44de38b80864c39731"
106// Sig := "35c323757c20640a294345c89c0bfcebe3d554fdb0c7b7a0bdb72222c531b1ec849fed99a053e0f5b02dd9a25bb6eb018885526d9f583cdbde0b1e9f6329da09"
107
108// myCircuit := Eddsa25519Circuit{
109// M: hexToBits(M),
110// Pk: hexToBits(Pk),
111// Sig: hexToBits(Sig),
112// }
113// fmt.Println(time.Now(), "compiling...")
114// r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &myCircuit)
115// if err != nil {
116// return err
117// }
118
119// assignment := &Eddsa25519Circuit{
120// M: hexToBits(M),
121// Pk: hexToBits(Pk),
122// Sig: hexToBits(Sig),
123// }
124// fmt.Println(time.Now(), "generating witness...")
125// witness, _ := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
126// publicWitness, _ := witness.Public()
127// fmt.Println(time.Now(), "groth setup...")
128// pk, vk, err := groth16.Setup(r1cs)
129// fmt.Println(time.Now(), "groth prove...")
130// proof, err := groth16.Prove(r1cs, pk, witness)
131// fmt.Println(time.Now(), "groth verify...")
132// err = groth16.Verify(proof, vk, publicWitness)
133// if err != nil {
134// return err
135// }
136// fmt.Println(proof)
137// return nil
138// }
139
140// func hexToBits(h string) []frontend.Variable {
141// b, err := hex.DecodeString(h)
142// if err != nil {
143// panic(err)
144// }
145// result := make([]frontend.Variable, len(b)*8)
146// for i, v := range b {
147// for j := 0; j < 8; j++ {
148// if (v & (1 << j)) != 0 {
149// result[i*8+j] = 1
150// } else {
151// result[i*8+j] = 0
152// }
153// }
154// }
155// return result
156// }
157
158// func bytesToBits(arr []byte) []frontend.Variable {
159// result := make([]frontend.Variable, len(arr)*8)
160// for i, v := range arr {
161// for j := 0; j < 8; j++ {
162// if (v & (1 << (7 - j))) != 0 {
163// result[i*8+j] = 1
164// } else {
165// result[i*8+j] = 0
166// }
167// }
168// }
169// return result
170// }
171
172type PoseidonCircuit struct {
173 In [12]frontend.Variable
174 Out [12]frontend.Variable
175}
176
177func (circuit *PoseidonCircuit) Define(api frontend.API) error {
178 poseidon.Poseidon(api, circuit.In, circuit.Out)
179 return nil
180}
181
182func main() {
183 in_str := [12]string{
184 "0",
185 "0",
186 "0",
187 "0",
188 "0",
189 "0",
190 "0",
191 "0",
192 "0",
193 "0",
194 "0",
195 "0",
196 }
197 out_str := [12]string{
198 "4330397376401421145",
199 "14124799381142128323",
200 "8742572140681234676",
201 "14345658006221440202",
202 "15524073338516903644",
203 "5091405722150716653",
204 "15002163819607624508",
205 "2047012902665707362",
206 "16106391063450633726",
207 "4680844749859802542",
208 "15019775476387350140",
209 "1698615465718385111",
210 }
211
212 var in [12]big.Int
213 var out [12]big.Int
214 for i := 0; i < 12; i++ {
215 n := new(big.Int)
216 n, _ = n.SetString(in_str[i], 10)
217 in[i] = *n
218 }
219 for i := 0; i < 12; i++ {
220 n := new(big.Int)
221 n, _ = n.SetString(out_str[i], 10)
222 out[i] = *n
223 }
224
225 var _in [12]frontend.Variable
226 var _out [12]frontend.Variable
227
228 for i := 0; i < 12; i++ {
229 _in[i] = in[i]
230 _out[i] = out[i]
231 }
232
233 myCircuit := PoseidonCircuit{
234 In: _in,
235 Out: _out,
236 }
237
238 fmt.Println(time.Now(), "compiling...")
239 r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &myCircuit)
240 if err != nil {
241 fmt.Println(err)
242 panic(err)
243 }
244
245 assignment := &PoseidonCircuit{
246 In: _in,
247 Out: _out,
248 }
249
250 witness, _ := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
251 publicWitness, err := witness.Public()
252 if err != nil {
253 panic(err)
254 }
255 fmt.Println(time.Now(), "groth setup...")
256 pk, vk, err := groth16.Setup(r1cs)
257 if err != nil {
258 panic(err)
259 }
260 err = test.IsSolved(&myCircuit, assignment, ecc.BN254.ScalarField())
261 if err != nil {
262 panic(err)
263 }
264
265 fmt.Println(time.Now(), "groth prove...")
266 proof, err := groth16.Prove(r1cs, pk, witness)
267 if err != nil {
268 panic(err)
269 }
270 fmt.Println(time.Now(), "groth verify...")
271
272 err = groth16.Verify(proof, vk, publicWitness)
273 if err != nil {
274 panic(err)
275 }
276
277}