mirror of
https://github.com/arnaucube/go-iden3-crypto.git
synced 2026-02-07 03:26:39 +01:00
add mimc7 & fields
This commit is contained in:
arnaucube
171
mimc7/mimc7.go
Normal file
171
mimc7/mimc7.go
Normal file
@@ -0,0 +1,171 @@
|
||||
package mimc7
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/big"
|
||||
|
||||
"github.com/ethereum/go-ethereum/crypto"
|
||||
"github.com/iden3/go-iden3/crypto/field"
|
||||
)
|
||||
|
||||
const SEED = "mimc"
|
||||
|
||||
// RElem is a big.Int of maximum 253 bits
|
||||
type RElem *big.Int
|
||||
|
||||
var constants = generateConstantsData()
|
||||
|
||||
type constantsData struct {
|
||||
maxFieldVal *big.Int
|
||||
seedHash *big.Int
|
||||
iv *big.Int
|
||||
fqR field.Fq
|
||||
nRounds int
|
||||
cts []*big.Int
|
||||
}
|
||||
|
||||
func getIV(seed string) {
|
||||
}
|
||||
|
||||
func generateConstantsData() constantsData {
|
||||
var constants constantsData
|
||||
|
||||
r, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
|
||||
if !ok {
|
||||
|
||||
}
|
||||
fqR := field.NewFq(r)
|
||||
constants.fqR = fqR
|
||||
|
||||
// maxFieldVal is the R value of the Finite Field
|
||||
constants.maxFieldVal = constants.fqR.Q
|
||||
|
||||
constants.seedHash = new(big.Int).SetBytes(crypto.Keccak256([]byte(SEED)))
|
||||
c := new(big.Int).SetBytes(crypto.Keccak256([]byte(SEED + "_iv")))
|
||||
constants.iv = new(big.Int).Mod(c, constants.maxFieldVal)
|
||||
|
||||
constants.nRounds = 91
|
||||
cts, err := getConstants(constants.fqR, SEED, constants.nRounds)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
constants.cts = cts
|
||||
return constants
|
||||
}
|
||||
|
||||
// BigIntToRElem checks if given big.Int fits in a Field R element, and returns the RElem type
|
||||
func BigIntToRElem(a *big.Int) (RElem, error) {
|
||||
if a.Cmp(constants.maxFieldVal) != -1 {
|
||||
return RElem(a), errors.New("Given big.Int don't fits in the Finite Field over R")
|
||||
}
|
||||
return RElem(a), nil
|
||||
}
|
||||
|
||||
//BigIntsToRElems converts from array of *big.Int to array of RElem
|
||||
func BigIntsToRElems(arr []*big.Int) ([]RElem, error) {
|
||||
o := make([]RElem, len(arr))
|
||||
for i, a := range arr {
|
||||
e, err := BigIntToRElem(a)
|
||||
if err != nil {
|
||||
return o, fmt.Errorf("element in position %v don't fits in Finite Field over R", i)
|
||||
}
|
||||
o[i] = e
|
||||
}
|
||||
return o, nil
|
||||
}
|
||||
|
||||
// RElemsToBigInts converts from array of RElem to array of *big.Int
|
||||
func RElemsToBigInts(arr []RElem) []*big.Int {
|
||||
o := make([]*big.Int, len(arr))
|
||||
for i, a := range arr {
|
||||
o[i] = a
|
||||
}
|
||||
return o
|
||||
}
|
||||
|
||||
func getConstants(fqR field.Fq, seed string, nRounds int) ([]*big.Int, error) {
|
||||
cts := make([]*big.Int, nRounds)
|
||||
cts[0] = big.NewInt(int64(0))
|
||||
c := new(big.Int).SetBytes(crypto.Keccak256([]byte(SEED)))
|
||||
for i := 1; i < nRounds; i++ {
|
||||
c = new(big.Int).SetBytes(crypto.Keccak256(c.Bytes()))
|
||||
|
||||
n := fqR.Affine(c)
|
||||
cts[i] = n
|
||||
}
|
||||
return cts, nil
|
||||
}
|
||||
|
||||
// MIMC7HashGeneric performs the MIMC7 hash over a RElem, in a generic way, where it can be specified the Finite Field over R, and the number of rounds
|
||||
func MIMC7HashGeneric(fqR field.Fq, xIn, k *big.Int, nRounds int) (*big.Int, error) {
|
||||
cts, err := getConstants(fqR, SEED, nRounds)
|
||||
if err != nil {
|
||||
return &big.Int{}, err
|
||||
}
|
||||
var r *big.Int
|
||||
for i := 0; i < nRounds; i++ {
|
||||
var t *big.Int
|
||||
if i == 0 {
|
||||
t = fqR.Add(xIn, k)
|
||||
} else {
|
||||
t = fqR.Add(fqR.Add(r, k), cts[i])
|
||||
}
|
||||
t2 := fqR.Square(t)
|
||||
t4 := fqR.Square(t2)
|
||||
r = fqR.Mul(fqR.Mul(t4, t2), t)
|
||||
}
|
||||
return fqR.Affine(fqR.Add(r, k)), nil
|
||||
}
|
||||
|
||||
// HashGeneric performs the MIMC7 hash over a RElem array, in a generic way, where it can be specified the Finite Field over R, and the number of rounds
|
||||
func HashGeneric(iv *big.Int, arrEl []RElem, fqR field.Fq, nRounds int) (RElem, error) {
|
||||
arr := RElemsToBigInts(arrEl)
|
||||
r := iv
|
||||
var err error
|
||||
for i := 0; i < len(arr); i++ {
|
||||
r, err = MIMC7HashGeneric(fqR, r, arr[i], nRounds)
|
||||
if err != nil {
|
||||
return r, err
|
||||
}
|
||||
}
|
||||
return RElem(r), nil
|
||||
}
|
||||
|
||||
// MIMC7Hash performs the MIMC7 hash over a RElem, using the Finite Field over R and the number of rounds setted in the `constants` variable
|
||||
func MIMC7Hash(xIn, k *big.Int) *big.Int {
|
||||
var r *big.Int
|
||||
for i := 0; i < constants.nRounds; i++ {
|
||||
var t *big.Int
|
||||
if i == 0 {
|
||||
t = constants.fqR.Add(xIn, k)
|
||||
} else {
|
||||
t = constants.fqR.Add(constants.fqR.Add(r, k), constants.cts[i])
|
||||
}
|
||||
t2 := constants.fqR.Square(t)
|
||||
t4 := constants.fqR.Square(t2)
|
||||
r = constants.fqR.Mul(constants.fqR.Mul(t4, t2), t)
|
||||
}
|
||||
return constants.fqR.Affine(constants.fqR.Add(r, k))
|
||||
}
|
||||
|
||||
// Hash performs the MIMC7 hash over a RElem array
|
||||
func Hash(arrEl []RElem, key *big.Int) RElem {
|
||||
arr := RElemsToBigInts(arrEl)
|
||||
var r *big.Int
|
||||
if key == nil {
|
||||
r = constants.fqR.Zero()
|
||||
} else {
|
||||
r = key
|
||||
}
|
||||
// r := constants.iv
|
||||
for i := 0; i < len(arr); i++ {
|
||||
r = constants.fqR.Add(
|
||||
constants.fqR.Add(
|
||||
r,
|
||||
arr[i],
|
||||
),
|
||||
MIMC7Hash(arr[i], r))
|
||||
}
|
||||
return RElem(r)
|
||||
}
|
||||
137
mimc7/mimc7_test.go
Normal file
137
mimc7/mimc7_test.go
Normal file
@@ -0,0 +1,137 @@
|
||||
package mimc7
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
"math/big"
|
||||
"testing"
|
||||
|
||||
"github.com/iden3/go-iden3/crypto/field"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestUtils(t *testing.T) {
|
||||
b1 := big.NewInt(int64(1))
|
||||
b2 := big.NewInt(int64(2))
|
||||
b3 := big.NewInt(int64(3))
|
||||
arrBigInt := []*big.Int{b1, b2, b3}
|
||||
|
||||
// *big.Int array to RElem array
|
||||
rElems, err := BigIntsToRElems(arrBigInt)
|
||||
assert.Nil(t, err)
|
||||
|
||||
// RElem array to *big.Int array
|
||||
bElems := RElemsToBigInts(rElems)
|
||||
|
||||
assert.Equal(t, arrBigInt, bElems)
|
||||
|
||||
r, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
|
||||
assert.True(t, ok)
|
||||
|
||||
// greater or equal than R will give error when passing bigInts to RElems, to fit in the R Finite Field
|
||||
overR, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495618", 10)
|
||||
assert.True(t, ok)
|
||||
_, err = BigIntsToRElems([]*big.Int{b1, overR, b2})
|
||||
assert.True(t, err != nil)
|
||||
|
||||
_, err = BigIntsToRElems([]*big.Int{b1, r, b2})
|
||||
assert.True(t, err != nil)
|
||||
|
||||
// smaller than R will not give error when passing bigInts to RElems, to fit in the R Finite Field
|
||||
underR, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495616", 10)
|
||||
assert.True(t, ok)
|
||||
_, err = BigIntsToRElems([]*big.Int{b1, underR, b2})
|
||||
assert.Nil(t, err)
|
||||
}
|
||||
|
||||
func TestMIMC7Generic(t *testing.T) {
|
||||
b1 := big.NewInt(int64(1))
|
||||
b2 := big.NewInt(int64(2))
|
||||
b3 := big.NewInt(int64(3))
|
||||
|
||||
r, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
|
||||
assert.True(t, ok)
|
||||
fqR := field.NewFq(r)
|
||||
|
||||
bigArray := []*big.Int{b1, b2, b3}
|
||||
elementsArray, err := BigIntsToRElems(bigArray)
|
||||
assert.Nil(t, err)
|
||||
|
||||
// Generic Hash
|
||||
mhg, err := MIMC7HashGeneric(fqR, b1, b2, 91)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, "10594780656576967754230020536574539122676596303354946869887184401991294982664", mhg.String())
|
||||
hg, err := HashGeneric(fqR.Zero(), elementsArray, fqR, 91)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, "6464402164086696096195815557694604139393321133243036833927490113253119343397", (*big.Int)(hg).String())
|
||||
}
|
||||
|
||||
func TestMIMC7(t *testing.T) {
|
||||
b12 := big.NewInt(int64(12))
|
||||
b45 := big.NewInt(int64(45))
|
||||
b78 := big.NewInt(int64(78))
|
||||
b41 := big.NewInt(int64(41))
|
||||
|
||||
// h1, hash of 1 elements
|
||||
bigArray1 := []*big.Int{b12}
|
||||
elementsArray1, err := BigIntsToRElems(bigArray1)
|
||||
assert.Nil(t, err)
|
||||
|
||||
h1 := Hash(elementsArray1, nil)
|
||||
assert.Nil(t, err)
|
||||
// same hash value than the iden3js and circomlib tests:
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(h1).Bytes()), "0x237c92644dbddb86d8a259e0e923aaab65a93f1ec5758b8799988894ac0958fd")
|
||||
|
||||
// h2a, hash of 2 elements
|
||||
bigArray2a := []*big.Int{b78, b41}
|
||||
elementsArray2a, err := BigIntsToRElems(bigArray2a)
|
||||
assert.Nil(t, err)
|
||||
|
||||
mh2a := MIMC7Hash(b12, b45)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(mh2a).Bytes()), "0x2ba7ebad3c6b6f5a20bdecba2333c63173ca1a5f2f49d958081d9fa7179c44e4")
|
||||
|
||||
h2a := Hash(elementsArray2a, nil)
|
||||
assert.Nil(t, err)
|
||||
// same hash value than the iden3js and circomlib tests:
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(h2a).Bytes()), "0x067f3202335ea256ae6e6aadcd2d5f7f4b06a00b2d1e0de903980d5ab552dc70")
|
||||
|
||||
// h2b, hash of 2 elements
|
||||
bigArray2b := []*big.Int{b12, b45}
|
||||
elementsArray2b, err := BigIntsToRElems(bigArray2b)
|
||||
assert.Nil(t, err)
|
||||
|
||||
mh2b := MIMC7Hash(b12, b45)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(mh2b).Bytes()), "0x2ba7ebad3c6b6f5a20bdecba2333c63173ca1a5f2f49d958081d9fa7179c44e4")
|
||||
|
||||
h2b := Hash(elementsArray2b, nil)
|
||||
assert.Nil(t, err)
|
||||
// same hash value than the iden3js and circomlib tests:
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(h2b).Bytes()), "0x15ff7fe9793346a17c3150804bcb36d161c8662b110c50f55ccb7113948d8879")
|
||||
|
||||
// h4, hash of 4 elements
|
||||
bigArray4 := []*big.Int{b12, b45, b78, b41}
|
||||
elementsArray4, err := BigIntsToRElems(bigArray4)
|
||||
assert.Nil(t, err)
|
||||
|
||||
h4 := Hash(elementsArray4, nil)
|
||||
assert.Nil(t, err)
|
||||
// same hash value than the iden3js and circomlib tests:
|
||||
assert.Equal(t, "0x"+hex.EncodeToString((*big.Int)(h4).Bytes()), "0x284bc1f34f335933a23a433b6ff3ee179d682cd5e5e2fcdd2d964afa85104beb")
|
||||
}
|
||||
|
||||
func BenchmarkMIMC7(b *testing.B) {
|
||||
b12 := big.NewInt(int64(12))
|
||||
b45 := big.NewInt(int64(45))
|
||||
b78 := big.NewInt(int64(78))
|
||||
b41 := big.NewInt(int64(41))
|
||||
bigArray4 := []*big.Int{b12, b45, b78, b41}
|
||||
elementsArray4, err := BigIntsToRElems(bigArray4)
|
||||
assert.Nil(b, err)
|
||||
|
||||
var h4 RElem
|
||||
for i := 0; i < b.N; i++ {
|
||||
h4 = Hash(elementsArray4, nil)
|
||||
}
|
||||
println(h4)
|
||||
}
|
||||
Reference in New Issue
Block a user