Merge branch 'develop' into fix/dashboard-drng

packages/binary/valuetransfer/address/address.go

@@ -34,6 +34,12 @@ func Random() (address Address) {
 	return
 }
 
+func RandomOfType(versionByte byte) Address {
+	ret := Random()
+	ret[0] = versionByte
+	return ret
+}
+
 // FromBase58 creates an address from a base58 encoded string.
 func FromBase58(base58String string) (address Address, err error) {
 	// decode string

packages/binary/valuetransfer/transaction/transaction.go

@@ -14,7 +14,7 @@ import (
 	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address/signaturescheme"
 )
 
-// region IMPLEMENT Transaction ///////////////////////////////////////////////////////////////////////////////////////////
+// region IMPLEMENT Transaction ////////////////////////////////////////////////////////////////////////////////////////////
 
 type Transaction struct {
 	objectstorage.StorableObjectFlags
@@ -32,6 +32,9 @@ type Transaction struct {
 	signatureBytes      []byte
 	signatureBytesMutex sync.RWMutex
 
+	dataPayload      []byte
+	dataPayloadMutex sync.RWMutex
+
 	bytes      []byte
 	bytesMutex sync.RWMutex
 }
@@ -182,6 +185,12 @@ func (transaction *Transaction) EssenceBytes() []byte {
 	// marshal outputs
 	marshalUtil.WriteBytes(transaction.outputs.Bytes())
 
+	// marshal dataPayload size
+	marshalUtil.WriteUint32(transaction.DataPayloadSize())
+
+	// marshal dataPayload data
+	marshalUtil.WriteBytes(transaction.dataPayload)
+
 	// store marshaled result
 	transaction.essenceBytes = marshalUtil.Bytes()
 
@@ -260,9 +269,42 @@ func (transaction *Transaction) String() string {
 		stringify.StructField("inputs", transaction.inputs),
 		stringify.StructField("outputs", transaction.outputs),
 		stringify.StructField("signatures", transaction.signatures),
+		stringify.StructField("dataPayloadSize", transaction.DataPayloadSize()),
 	)
 }
 
+// max dataPayload size limit
+const MAX_DATA_PAYLOAD_SIZE = 64 * 1024
+
+// SetDataPayload sets yhe dataPayload and its type
+func (transaction *Transaction) SetDataPayload(data []byte) error {
+	transaction.dataPayloadMutex.Lock()
+	defer transaction.dataPayloadMutex.Unlock()
+
+	if len(data) > MAX_DATA_PAYLOAD_SIZE {
+		return fmt.Errorf("maximum dataPayload size of %d bytes exceeded", MAX_DATA_PAYLOAD_SIZE)
+	}
+	transaction.dataPayload = data
+	return nil
+}
+
+// GetDataPayload gets the dataPayload and its type
+func (transaction *Transaction) GetDataPayload() []byte {
+	transaction.dataPayloadMutex.RLock()
+	defer transaction.dataPayloadMutex.RUnlock()
+
+	return transaction.dataPayload
+}
+
+// DataPayloadSize returns the size of the dataPayload as uint32.
+// nil payload as size 0
+func (transaction *Transaction) DataPayloadSize() uint32 {
+	transaction.dataPayloadMutex.RLock()
+	defer transaction.dataPayloadMutex.RUnlock()
+
+	return uint32(len(transaction.dataPayload))
+}
+
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // region IMPLEMENT StorableObject interface ///////////////////////////////////////////////////////////////////////////
@@ -301,6 +343,24 @@ func (transaction *Transaction) UnmarshalObjectStorageValue(bytes []byte) (err e
 	}
 	transaction.outputs = parsedOutputs.(*Outputs)
 
+	// unmarshal data payload size
+	var dataPayloadSize uint32
+	dataPayloadSize, err = marshalUtil.ReadUint32()
+	if err != nil {
+		return
+	}
+	if dataPayloadSize > MAX_DATA_PAYLOAD_SIZE {
+		err = fmt.Errorf("data payload size of %d bytes exceeds maximum limit of %d bytes",
+			dataPayloadSize, MAX_DATA_PAYLOAD_SIZE)
+		return
+	}
+
+	// unmarshal data payload
+	transaction.dataPayload, err = marshalUtil.ReadBytes(int(dataPayloadSize))
+	if err != nil {
+		return
+	}
+
 	// store essence bytes
 	essenceBytesCount := marshalUtil.ReadOffset()
 	transaction.essenceBytes = make([]byte, essenceBytesCount)

packages/binary/valuetransfer/transaction/transaction_test.go

+package transaction
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address"
+	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address/signaturescheme"
+	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/balance"
+	"github.com/iotaledger/hive.go/crypto/ed25519"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEmptyDataPayload(t *testing.T) {
+	sigScheme := signaturescheme.ED25519(ed25519.GenerateKeyPair())
+	addr := sigScheme.Address()
+	o1 := NewOutputId(addr, RandomId())
+	inputs := NewInputs(o1)
+	bal := balance.New(balance.COLOR_IOTA, 1)
+	outputs := NewOutputs(map[address.Address][]*balance.Balance{addr: {bal}})
+	tx := New(inputs, outputs)
+	tx.Sign(sigScheme)
+	check := tx.SignaturesValid()
+
+	assert.Equal(t, true, check)
+}
+
+func TestShortDataPayload(t *testing.T) {
+	sigScheme := signaturescheme.ED25519(ed25519.GenerateKeyPair())
+	addr := sigScheme.Address()
+	o1 := NewOutputId(addr, RandomId())
+	inputs := NewInputs(o1)
+	bal := balance.New(balance.COLOR_IOTA, 1)
+	outputs := NewOutputs(map[address.Address][]*balance.Balance{addr: {bal}})
+	tx := New(inputs, outputs)
+
+	dataPayload := []byte("data payload test")
+	err := tx.SetDataPayload(dataPayload)
+	assert.Equal(t, nil, err)
+
+	dpBack := tx.GetDataPayload()
+	assert.Equal(t, true, bytes.Equal(dpBack, dataPayload))
+
+	tx.Sign(sigScheme)
+	check := tx.SignaturesValid()
+	assert.Equal(t, true, check)
+
+	// corrupt data payload bytes
+	// reset essence to force recalculation
+	tx.essenceBytes = nil
+	dataPayload[2] = '?'
+	err = tx.SetDataPayload(dataPayload)
+	assert.Equal(t, nil, err)
+
+	// expect signature is not valid
+	check = tx.SignaturesValid()
+	assert.Equal(t, false, check)
+}
+
+func TestTooLongDataPayload(t *testing.T) {
+	sigScheme := signaturescheme.ED25519(ed25519.GenerateKeyPair())
+	addr := sigScheme.Address()
+	o1 := NewOutputId(addr, RandomId())
+	inputs := NewInputs(o1)
+	bal := balance.New(balance.COLOR_IOTA, 1)
+	outputs := NewOutputs(map[address.Address][]*balance.Balance{addr: {bal}})
+	tx := New(inputs, outputs)
+
+	dataPayload := []byte(strings.Repeat("1", MAX_DATA_PAYLOAD_SIZE+1))
+	err := tx.SetDataPayload(dataPayload)
+	assert.Equal(t, true, err != nil)
+}
+
+func TestMarshalingEmptyDataPayload(t *testing.T) {
+	sigScheme := signaturescheme.RandBLS()
+	addr := sigScheme.Address()
+	o1 := NewOutputId(addr, RandomId())
+	inputs := NewInputs(o1)
+	bal := balance.New(balance.COLOR_IOTA, 1)
+	outputs := NewOutputs(map[address.Address][]*balance.Balance{addr: {bal}})
+	tx := New(inputs, outputs)
+
+	tx.Sign(sigScheme)
+	check := tx.SignaturesValid()
+	assert.Equal(t, true, check)
+
+	v := tx.ObjectStorageValue()
+
+	tx1 := Transaction{}
+	err, _ := tx1.UnmarshalObjectStorageValue(v)
+	if err != nil {
+		assert.Error(t, err)
+	}
+	assert.Equal(t, true, tx1.SignaturesValid())
+	assert.Equal(t, true, bytes.Equal(tx1.Id().Bytes(), tx.Id().Bytes()))
+}
+
+func TestMarshalingDataPayload(t *testing.T) {
+	sigScheme := signaturescheme.RandBLS()
+	addr := sigScheme.Address()
+	o1 := NewOutputId(addr, RandomId())
+	inputs := NewInputs(o1)
+	bal := balance.New(balance.COLOR_IOTA, 1)
+	outputs := NewOutputs(map[address.Address][]*balance.Balance{addr: {bal}})
+	tx := New(inputs, outputs)
+
+	dataPayload := []byte("data payload test")
+	err := tx.SetDataPayload(dataPayload)
+	assert.Equal(t, nil, err)
+
+	tx.Sign(sigScheme)
+	check := tx.SignaturesValid()
+	assert.Equal(t, true, check)
+
+	v := tx.ObjectStorageValue()
+
+	tx1 := Transaction{}
+	err, _ = tx1.UnmarshalObjectStorageValue(v)
+
+	assert.Equal(t, nil, err)
+	assert.Equal(t, true, tx1.SignaturesValid())
+
+	assert.Equal(t, true, bytes.Equal(tx1.Id().Bytes(), tx.Id().Bytes()))
+}

packages/gossip/manager_test.go

@@ -387,7 +387,7 @@ func TestDropNeighbor(t *testing.T) {
 
 		go func() { assert.NoError(t, mgrA.AddInbound(peerB)) }()
 		go func() { assert.NoError(t, mgrB.AddOutbound(peerA)) }()
-		wg.Wait() // wait until the events were triggered
+		wg.Wait() // wait until the events were triggered and the peers are connected
 	}
 	disc := func() {
 		var wg sync.WaitGroup
@@ -396,9 +396,17 @@ func TestDropNeighbor(t *testing.T) {
 		Events.NeighborRemoved.Attach(closure)
 		defer Events.NeighborRemoved.Detach(closure)
 
-		go func() { _ = mgrA.DropNeighbor(peerB.ID()) }()
-		go func() { _ = mgrB.DropNeighbor(peerA.ID()) }()
-		wg.Wait() // wait until the events were triggered
+		// assure that no DropNeighbor calls are leaking
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			_ = mgrA.DropNeighbor(peerB.ID())
+		}()
+		go func() {
+			defer wg.Done()
+			_ = mgrB.DropNeighbor(peerA.ID())
+		}()
+		wg.Wait() // wait until the events were triggered and the go routines are done
 	}
 
 	// drop and connect many many times

plugins/webauth/parameters.go

@@ -5,13 +5,16 @@ import (
 )
 
 const (
-	WEBAPI_AUTH_USERNAME    = "webapi.auth.username"
-	WEBAPI_AUTH_PASSWORD    = "webapi.auth.password"
-	WEBAPI_AUTH_PRIVATE_KEY = "webapi.auth.privateKey"
+	// CfgWebAPIAuthUsername defines the config flag of the web API authentication username.
+	CfgWebAPIAuthUsername = "webapi.auth.username"
+	// CfgWebAPIAuthPassword defines the config flag of the web API authentication password.
+	CfgWebAPIAuthPassword = "webapi.auth.password"
+	// CfgWebAPIAuthPrivateKey defines the config flag of the web API authentication private key.
+	CfgWebAPIAuthPrivateKey = "webapi.auth.privateKey"
 )
 
 func init() {
-	flag.String(WEBAPI_AUTH_USERNAME, "goshimmer", "username for the webapi")
-	flag.String(WEBAPI_AUTH_PASSWORD, "goshimmer", "password for the webapi")
-	flag.String(WEBAPI_AUTH_PRIVATE_KEY, "", "private key used to sign the JWTs")
+	flag.String(CfgWebAPIAuthUsername, "goshimmer", "username for the webapi")
+	flag.String(CfgWebAPIAuthPassword, "goshimmer", "password for the webapi")
+	flag.String(CfgWebAPIAuthPrivateKey, "", "private key used to sign the JWTs")
 }

plugins/webauth/webauth.go

@@ -5,15 +5,13 @@ import (
 	"strings"
 	"time"
 
+	"github.com/dgrijalva/jwt-go"
+	"github.com/iotaledger/goshimmer/plugins/config"
+	"github.com/iotaledger/goshimmer/plugins/webapi"
 	"github.com/iotaledger/hive.go/logger"
 	"github.com/iotaledger/hive.go/node"
 	"github.com/labstack/echo"
 	"github.com/labstack/echo/middleware"
-
-	"github.com/iotaledger/goshimmer/plugins/config"
-	"github.com/iotaledger/goshimmer/plugins/webapi"
-
-	"github.com/dgrijalva/jwt-go"
 )
 
 // PluginName is the name of the web API auth plugin.
@@ -28,7 +26,7 @@ var (
 
 func configure(plugin *node.Plugin) {
 	log = logger.NewLogger(PluginName)
-	privateKey = config.Node.GetString(WEBAPI_AUTH_PRIVATE_KEY)
+	privateKey = config.Node.GetString(CfgWebAPIAuthPrivateKey)
 	if len(privateKey) == 0 {
 		panic("")
 	}
@@ -47,23 +45,29 @@ func configure(plugin *node.Plugin) {
 	log.Info("WebAPI is now secured through JWT authentication")
 }
 
+// Request defines the struct of the request.
 type Request struct {
+	// Username is the username of the request.
 	Username string `json:"username"`
+	// Password is the password of the request.
 	Password string `json:"password"`
 }
 
+// Response defines the struct of the response.
 type Response struct {
+	// Token is the json web token.
 	Token string `json:"token"`
 }
 
+// Handler handles the web auth request.
 func Handler(c echo.Context) error {
 	login := &Request{}
 	if err := c.Bind(login); err != nil {
 		return echo.ErrBadRequest
 	}
 
-	if login.Username != config.Node.GetString(WEBAPI_AUTH_USERNAME) ||
-		login.Password != config.Node.GetString(WEBAPI_AUTH_PASSWORD) {
+	if login.Username != config.Node.GetString(CfgWebAPIAuthUsername) ||
+		login.Password != config.Node.GetString(CfgWebAPIAuthPassword) {
 		return echo.ErrUnauthorized
 	}