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		"1672775540645840396591609181675628451599263765380031905495115170613215233181",
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		"9d043ece562a8f82bfc0adb640c0107a7d3a27c1c7c1a6179a0da73de5c1b203",
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 compatibility
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 TestPublicKeyScannerValuer(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 TestPublicKeyCompScannerValuer(t *testing.T) {
179	privKValue := NewRandPrivKey()
180	pubKCompValue := privKValue.Public().Compress()
181	privKScan := NewRandPrivKey()
182	pubKCompScan := privKScan.Public().Compress()
183	var value driver.Valuer
184	var scan sql.Scanner
185	value = &pubKCompValue
186	scan = &pubKCompScan
187	fromDB, err := value.Value()
188	assert.Nil(t, err)
189	assert.Nil(t, scan.Scan(fromDB))
190	assert.Equal(t, value, scan)
191}
192
193func BenchmarkBabyjubEddsa(b *testing.B) {
194	var k PrivateKey
195	_, err := hex.Decode(k[:],
196		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
197	require.Nil(b, err)
198	pk := k.Public()
199
200	const n = 256
201
202	msgBuf, err := hex.DecodeString("00010203040506070809")
203	if err != nil {
204		panic(err)
205	}
206	msg := utils.SetBigIntFromLEBytes(new(big.Int), msgBuf)
207	var msgs [n]*big.Int
208	for i := 0; i < n; i++ {
209		msgs[i] = new(big.Int).Add(msg, big.NewInt(int64(i)))
210	}
211	var sigs [n]*Signature
212
213	b.Run("SignMimc7", func(b *testing.B) {
214		for i := 0; i < b.N; i++ {
215			k.SignMimc7(msgs[i%n])
216		}
217	})
218
219	for i := 0; i < n; i++ {
220		sigs[i%n] = k.SignMimc7(msgs[i%n])
221	}
222
223	b.Run("VerifyMimc7", func(b *testing.B) {
224		for i := 0; i < b.N; i++ {
225			pk.VerifyMimc7(msgs[i%n], sigs[i%n])
226		}
227	})
228
229	b.Run("SignPoseidon", func(b *testing.B) {
230		for i := 0; i < b.N; i++ {
231			k.SignPoseidon(msgs[i%n])
232		}
233	})
234
235	for i := 0; i < n; i++ {
236		sigs[i%n] = k.SignPoseidon(msgs[i%n])
237	}
238
239	b.Run("VerifyPoseidon", func(b *testing.B) {
240		for i := 0; i < b.N; i++ {
241			pk.VerifyPoseidon(msgs[i%n], sigs[i%n])
242		}
243	})
244}