1package babyjub
  2
  3import (
  4	"database/sql"
  5	"database/sql/driver"
  6	"encoding/hex"
  7	"fmt"
  8	"math/big"
  9	"testing"
 10
 11	"github.com/iden3/go-iden3-crypto/constants"
 12	"github.com/iden3/go-iden3-crypto/utils"
 13	"github.com/stretchr/testify/assert"
 14	"github.com/stretchr/testify/require"
 15)
 16
 17func TestPublicKey(t *testing.T) {
 18	var k PrivateKey
 19	for i := 0; i < 32; i++ {
 20		k[i] = byte(i)
 21	}
 22	pk := k.Public()
 23	assert.True(t, pk.X.Cmp(constants.Q) == -1)
 24	assert.True(t, pk.Y.Cmp(constants.Q) == -1)
 25}
 26
 27func TestSignVerifyMimc7(t *testing.T) {
 28	var k PrivateKey
 29	_, err := hex.Decode(k[:],
 30		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 31	require.Nil(t, err)
 32	msgBuf, err := hex.DecodeString("00010203040506070809")
 33	if err != nil {
 34		panic(err)
 35	}
 36	msg := utils.SetBigIntFromLEBytes(new(big.Int), msgBuf)
 37
 38	pk := k.Public()
 39	assert.Equal(t,
 40		"13277427435165878497778222415993513565335242147425444199013288855685581939618",
 41		pk.X.String())
 42	assert.Equal(t,
 43		"13622229784656158136036771217484571176836296686641868549125388198837476602820",
 44		pk.Y.String())
 45
 46	sig := k.SignMimc7(msg)
 47	assert.Equal(t,
 48		"11384336176656855268977457483345535180380036354188103142384839473266348197733",
 49		sig.R8.X.String())
 50	assert.Equal(t,
 51		"15383486972088797283337779941324724402501462225528836549661220478783371668959",
 52		sig.R8.Y.String())
 53	assert.Equal(t,
 54		"2523202440825208709475937830811065542425109372212752003460238913256192595070",
 55		sig.S.String())
 56
 57	ok := pk.VerifyMimc7(msg, sig)
 58	assert.Equal(t, true, ok)
 59
 60	sigBuf := sig.Compress()
 61	sig2, err := new(Signature).Decompress(sigBuf)
 62	assert.Equal(t, nil, err)
 63
 64	assert.Equal(t, ""+
 65		"dfedb4315d3f2eb4de2d3c510d7a987dcab67089c8ace06308827bf5bcbe02a2"+
 66		"7ed40dab29bf993c928e789d007387998901a24913d44fddb64b1f21fc149405",
 67		hex.EncodeToString(sigBuf[:]))
 68
 69	ok = pk.VerifyMimc7(msg, sig2)
 70	assert.Equal(t, true, ok)
 71}
 72
 73func TestSignVerifyPoseidon(t *testing.T) {
 74	var k PrivateKey
 75	_, err := hex.Decode(k[:],
 76		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 77	require.Nil(t, err)
 78	msgBuf, err := hex.DecodeString("00010203040506070809")
 79	if err != nil {
 80		panic(err)
 81	}
 82	msg := utils.SetBigIntFromLEBytes(new(big.Int), msgBuf)
 83
 84	pk := k.Public()
 85	assert.Equal(t,
 86		"13277427435165878497778222415993513565335242147425444199013288855685581939618",
 87		pk.X.String())
 88	assert.Equal(t,
 89		"13622229784656158136036771217484571176836296686641868549125388198837476602820",
 90		pk.Y.String())
 91
 92	sig := k.SignPoseidon(msg)
 93	assert.Equal(t,
 94		"11384336176656855268977457483345535180380036354188103142384839473266348197733",
 95		sig.R8.X.String())
 96	assert.Equal(t,
 97		"15383486972088797283337779941324724402501462225528836549661220478783371668959",
 98		sig.R8.Y.String())
 99	assert.Equal(t,
100		"1398758333392199195742243841591064350253744445503462896781493968760929513778",
101		sig.S.String())
102
103	ok := pk.VerifyPoseidon(msg, sig)
104	assert.Equal(t, true, ok)
105
106	sigBuf := sig.Compress()
107	sig2, err := new(Signature).Decompress(sigBuf)
108	assert.Equal(t, nil, err)
109
110	assert.Equal(t, ""+
111		"dfedb4315d3f2eb4de2d3c510d7a987dcab67089c8ace06308827bf5bcbe02a2"+
112		"32f16b0f2f4c4e1169aa59685637e1429b6581a9531d058d65f4ab224eab1703",
113		hex.EncodeToString(sigBuf[:]))
114
115	ok = pk.VerifyPoseidon(msg, sig2)
116	assert.Equal(t, true, ok)
117}
118
119func TestCompressDecompress(t *testing.T) {
120	var k PrivateKey
121	_, err := hex.Decode(k[:],
122		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
123	require.Nil(t, err)
124	pk := k.Public()
125	for i := 0; i < 64; i++ {
126		msgBuf, err := hex.DecodeString(fmt.Sprintf("000102030405060708%02d", i))
127		if err != nil {
128			panic(err)
129		}
130		msg := utils.SetBigIntFromLEBytes(new(big.Int), msgBuf)
131		sig := k.SignMimc7(msg)
132		sigBuf := sig.Compress()
133		sig2, err := new(Signature).Decompress(sigBuf)
134		assert.Equal(t, nil, err)
135		ok := pk.VerifyMimc7(msg, sig2)
136		assert.Equal(t, true, ok)
137	}
138}
139
140func TestSignatureCompScannerValuer(t *testing.T) {
141	privK := NewRandPrivKey()
142	var value driver.Valuer //nolint:gosimple this is done to ensure interface compability
143	value = privK.SignPoseidon(big.NewInt(674238462)).Compress()
144	scan := privK.SignPoseidon(big.NewInt(1)).Compress()
145	fromDB, err := value.Value()
146	assert.Nil(t, err)
147	assert.Nil(t, scan.Scan(fromDB))
148	assert.Equal(t, value, scan)
149}
150
151func TestSignatureScannerValuer(t *testing.T) {
152	privK := NewRandPrivKey()
153	var value driver.Valuer
154	var scan sql.Scanner
155	value = privK.SignPoseidon(big.NewInt(674238462))
156	scan = privK.SignPoseidon(big.NewInt(1))
157	fromDB, err := value.Value()
158	assert.Nil(t, err)
159	assert.Nil(t, scan.Scan(fromDB))
160	assert.Equal(t, value, scan)
161}
162
163func TestPubKeyScannerValuer(t *testing.T) {
164	privKValue := NewRandPrivKey()
165	pubKValue := privKValue.Public()
166	privKScan := NewRandPrivKey()
167	pubKScan := privKScan.Public()
168	var value driver.Valuer
169	var scan sql.Scanner
170	value = pubKValue
171	scan = pubKScan
172	fromDB, err := value.Value()
173	assert.Nil(t, err)
174	assert.Nil(t, scan.Scan(fromDB))
175	assert.Equal(t, value, scan)
176}
177
178func BenchmarkBabyjubEddsa(b *testing.B) {
179	var k PrivateKey
180	_, err := hex.Decode(k[:],
181		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
182	require.Nil(b, err)
183	pk := k.Public()
184
185	const n = 256
186
187	msgBuf, err := hex.DecodeString("00010203040506070809")
188	if err != nil {
189		panic(err)
190	}
191	msg := utils.SetBigIntFromLEBytes(new(big.Int), msgBuf)
192	var msgs [n]*big.Int
193	for i := 0; i < n; i++ {
194		msgs[i] = new(big.Int).Add(msg, big.NewInt(int64(i)))
195	}
196	var sigs [n]*Signature
197
198	b.Run("SignMimc7", func(b *testing.B) {
199		for i := 0; i < b.N; i++ {
200			k.SignMimc7(msgs[i%n])
201		}
202	})
203
204	for i := 0; i < n; i++ {
205		sigs[i%n] = k.SignMimc7(msgs[i%n])
206	}
207
208	b.Run("VerifyMimc7", func(b *testing.B) {
209		for i := 0; i < b.N; i++ {
210			pk.VerifyMimc7(msgs[i%n], sigs[i%n])
211		}
212	})
213
214	b.Run("SignPoseidon", func(b *testing.B) {
215		for i := 0; i < b.N; i++ {
216			k.SignPoseidon(msgs[i%n])
217		}
218	})
219
220	for i := 0; i < n; i++ {
221		sigs[i%n] = k.SignPoseidon(msgs[i%n])
222	}
223
224	b.Run("VerifyPoseidon", func(b *testing.B) {
225		for i := 0; i < b.N; i++ {
226			pk.VerifyPoseidon(msgs[i%n], sigs[i%n])
227		}
228	})
229}