github.com/dusk-network/dusk-crypto@v0.1.3/mlsag/mlsag_test.go (about)

     1  package mlsag
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	ristretto "github.com/bwesterb/go-ristretto"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestEncodeDecode(t *testing.T) {
    12  	proof := generateRandProof(20, 10)
    13  
    14  	includeKeys := false
    15  	sig, keyImages, err := proof.prove(true)
    16  	assert.Nil(t, err)
    17  	assert.NotNil(t, keyImages)
    18  	encodeDecodeSig(t, sig, includeKeys)
    19  
    20  	includeKeys = true
    21  	sig, keyImages, err = proof.prove(true)
    22  	assert.Nil(t, err)
    23  	assert.NotNil(t, keyImages)
    24  	encodeDecodeSig(t, sig, includeKeys)
    25  }
    26  
    27  func encodeDecodeSig(t *testing.T, sig *Signature, includeKeys bool) {
    28  	buf := &bytes.Buffer{}
    29  
    30  	err := sig.Encode(buf, includeKeys)
    31  	assert.Nil(t, err)
    32  
    33  	decodedSig := &Signature{}
    34  	err = decodedSig.Decode(buf, includeKeys)
    35  	assert.Nil(t, err)
    36  
    37  	ok := sig.Equals(*decodedSig, includeKeys)
    38  	assert.True(t, ok)
    39  }
    40  func TestGenNonces(t *testing.T) {
    41  	for i := 1; i < 20; i++ {
    42  		nonces := generateNonces(i)
    43  		assert.Equal(t, i, len(nonces))
    44  	}
    45  }
    46  
    47  func TestShuffleSet(t *testing.T) {
    48  	numUsers := 3
    49  	numKeys := 1
    50  
    51  	proof := generateRandProof(numUsers, numKeys)
    52  	proof.addSignerPubKey()
    53  	err := proof.shuffleSet()
    54  	assert.Equal(t, nil, err)
    55  
    56  	signersPubKeys := proof.pubKeysMatrix[proof.index]
    57  	assert.Equal(t, false, signersPubKeys.decoy)
    58  }
    59  
    60  func TestMLSAGProveVerify(t *testing.T) {
    61  
    62  	numUsers := 10
    63  	numKeys := 3
    64  	skipLastKeyImage := true
    65  
    66  	proof := generateRandProof(numUsers, numKeys)
    67  
    68  	sig, keyImages, err := proof.prove(true)
    69  	assert.Equal(t, nil, err)
    70  
    71  	if skipLastKeyImage {
    72  		assert.Equal(t, numKeys-1, len(keyImages))
    73  	} else {
    74  		assert.Equal(t, numKeys, len(keyImages))
    75  	}
    76  	assert.Equal(t, numUsers, len(sig.PubKeys))
    77  	assert.Equal(t, proof.calculateKeyImages(skipLastKeyImage), keyImages)
    78  	assert.Equal(t, proof.pubKeysMatrix, sig.PubKeys)
    79  	assert.Equal(t, proof.msg, sig.Msg)
    80  
    81  	ok, err := sig.Verify(keyImages)
    82  	assert.Equal(t, nil, err)
    83  	assert.True(t, ok)
    84  }
    85  
    86  func TestMLSAGBadSig(t *testing.T) {
    87  
    88  	numUsers := 12
    89  	numKeys := 10
    90  
    91  	proof := generateRandProof(numUsers, numKeys)
    92  
    93  	sig, keyImages, err := proof.prove(true)
    94  	assert.Equal(t, nil, err)
    95  
    96  	sig.Msg = []byte("something random")
    97  
    98  	ok, err := sig.Verify(keyImages)
    99  	assert.NotNil(t, err)
   100  	assert.False(t, ok)
   101  }
   102  
   103  func generateDecoy(n int) PubKeys {
   104  	var pKeys PubKeys
   105  
   106  	for i := 0; i < n; i++ {
   107  		var randPoint ristretto.Point
   108  		randPoint.Rand()
   109  		pKeys.AddPubKey(randPoint)
   110  	}
   111  
   112  	return pKeys
   113  }
   114  
   115  func generateDecoys(m int, n int) []PubKeys {
   116  	var matrixPubKeys []PubKeys
   117  	for i := 0; i < m; i++ {
   118  		matrixPubKeys = append(matrixPubKeys, generateDecoy(n))
   119  	}
   120  	return matrixPubKeys
   121  }
   122  
   123  func generatePrivKeys(m int) PrivKeys {
   124  	var privKeys PrivKeys
   125  	for i := 0; i < m; i++ {
   126  		var p ristretto.Scalar
   127  		p.Rand()
   128  		privKeys.AddPrivateKey(p)
   129  	}
   130  	return privKeys
   131  }
   132  
   133  func generateRandProof(numUsers, numKeys int) *Proof {
   134  	proof := &Proof{}
   135  
   136  	numDecoys := numUsers - 1
   137  
   138  	// Generate and add decoys to proof
   139  	matrixPubKeys := generateDecoys(numDecoys, numKeys)
   140  	for i := 0; i < len(matrixPubKeys); i++ {
   141  		pubKeys := matrixPubKeys[i]
   142  		proof.AddDecoy(pubKeys)
   143  	}
   144  
   145  	// Generate and add private keys to proof
   146  	privKeys := generatePrivKeys(numKeys)
   147  	for i := range privKeys {
   148  		proof.AddSecret(privKeys[i])
   149  	}
   150  
   151  	proof.msg = []byte("hello world")
   152  
   153  	return proof
   154  }