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
 17
 18import (
 19    "time"
 20    "fmt"
 21    "os"
 22    "encoding/hex"
 23    "github.com/consensys/gnark/frontend"
 24    "github.com/consensys/gnark-crypto/ecc"
 25    "github.com/consensys/gnark/frontend/cs/r1cs"
 26    "github.com/consensys/gnark/backend/groth16"
 27    "gnark-ed25519/edwards_curve"
 28    "gnark-ed25519/sha512"
 29)
 30
 31type Eddsa25519Circuit struct {
 32    M []frontend.Variable
 33    Pk []frontend.Variable
 34    Sig []frontend.Variable
 35}
 36
 37func (circuit *Eddsa25519Circuit) Define(api frontend.API) error {
 38    c, err := edwards_curve.New[edwards_curve.Ed25519, edwards_curve.Ed25519Scalars](api)
 39    if err != nil {
 40        return err
 41    }
 42    edwards_curve.CheckValid(c, circuit.Sig, circuit.M, circuit.Pk)
 43    return nil
 44}
 45
 46
 47type Sha512Circuit struct {
 48    in []frontend.Variable `gnark:"in"`
 49    out []frontend.Variable `gnark:"out"`
 50}
 51
 52func (circuit *Sha512Circuit) Define(api frontend.API) error {
 53    res := sha512.Sha512(api, circuit.in)
 54    if len(res) != 512 { panic("bad length") }
 55    for i := 0; i < 512; i++ {
 56        api.AssertIsEqual(res[i], circuit.out[i])
 57    }
 58    return nil
 59}
 60
 61
 62
 63func main() {
 64    err := mainImpl()
 65    if err != nil {
 66        fmt.Println(err)
 67        os.Exit(1)
 68    }
 69}
 70
 71// func mainImpl() error {
 72//     in := bytesToBits([]byte("Succinct Labs"))
 73//     out := hexToBits("503ace098aa03f6feec1b5df0a38aee923f744a775508bc81f2b94ad139be297c2e8cd8c44af527b5d3f017a7fc929892c896604047e52e3f518924f52bff0dc")
 74
 75//     myCircuit := Sha512Circuit{
 76//         in,
 77//         out,
 78//     }
 79//     fmt.Println(time.Now(), "compiling...")
 80//     r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &myCircuit)
 81//     if err != nil {
 82//         return err
 83//     }
 84
 85//     assignment := &Sha512Circuit{
 86//         in,
 87//         out,
 88//     }
 89//     fmt.Println(time.Now(), "generating witness...")
 90//     witness, _ := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
 91//     publicWitness, _ := witness.Public()
 92//     fmt.Println(time.Now(), "groth setup...")
 93//     pk, vk, err := groth16.Setup(r1cs)
 94//     fmt.Println(time.Now(), "groth prove...")
 95//     proof, err := groth16.Prove(r1cs, pk, witness)
 96//     fmt.Println(time.Now(), "groth verify...")
 97//     err = groth16.Verify(proof, vk, publicWitness)
 98//     if err != nil {
 99//         return err
100//     }
101//     fmt.Println(proof)
102//     return nil
103// }
104
105func mainImpl() error {
106    M := "53756363696e6374204c616273"
107    Pk := "f7ec1c43f4de9d49556de87b86b26a98942cb078486fdb44de38b80864c39731"
108    Sig := "35c323757c20640a294345c89c0bfcebe3d554fdb0c7b7a0bdb72222c531b1ec849fed99a053e0f5b02dd9a25bb6eb018885526d9f583cdbde0b1e9f6329da09"
109
110    myCircuit := Eddsa25519Circuit{
111        M: hexToBits(M),
112        Pk: hexToBits(Pk),
113        Sig: hexToBits(Sig),
114    }
115    fmt.Println(time.Now(), "compiling...")
116    r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &myCircuit)
117    if err != nil {
118        return err
119    }
120
121    assignment := &Eddsa25519Circuit{
122        M: hexToBits(M),
123        Pk: hexToBits(Pk),
124        Sig: hexToBits(Sig),
125    }
126    fmt.Println(time.Now(), "generating witness...")
127    witness, _ := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
128    publicWitness, _ := witness.Public()
129    fmt.Println(time.Now(), "groth setup...")
130    pk, vk, err := groth16.Setup(r1cs)
131    fmt.Println(time.Now(), "groth prove...")
132    proof, err := groth16.Prove(r1cs, pk, witness)
133    fmt.Println(time.Now(), "groth verify...")
134    err = groth16.Verify(proof, vk, publicWitness)
135    if err != nil {
136        return err
137    }
138    fmt.Println(proof)
139    return nil
140}
141
142func hexToBits(h string) []frontend.Variable {
143    b, err := hex.DecodeString(h)
144    if err != nil {
145        panic(err)
146    }
147    result := make([]frontend.Variable, len(b) * 8)
148    for i, v := range b {
149        for j := 0; j < 8; j++ {
150            if (v & (1 << j)) != 0 {
151                result[i*8+j] = 1
152            } else {
153                result[i*8+j] = 0
154            }
155        }
156    }
157    return result
158}
159
160func bytesToBits(arr []byte) []frontend.Variable {
161    result := make([]frontend.Variable, len(arr) * 8)
162    for i, v := range arr {
163        for j := 0; j < 8; j++ {
164            if (v & (1 << (7-j))) != 0 {
165                result[i*8+j] = 1
166            } else {
167                result[i*8+j] = 0
168            }
169        }
170    }
171    return result
172}