pss: refactor msgParams to message.Flags and RLP serialization

Author: jpeletier

pss/forwarding_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ethersphere/swarm/network"
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/pot"
+	"github.com/ethersphere/swarm/pss/internal/message"
 )
 
 type testCase struct {
@@ -347,7 +348,7 @@ func newTestDiscoveryPeer(addr pot.Address, kad *network.Kademlia) *network.Peer
 }
 
 func newTestMsg(addr []byte) *PssMsg {
-	msg := newPssMsg(&msgParams{})
+	msg := newPssMsg(message.Flags{})
 	msg.To = addr[:]
 	msg.Expire = uint32(time.Now().Add(time.Second * 60).Unix())
 	msg.Topic = [4]byte{}

pss/internal/message/flags.go

@@ -0,0 +1,48 @@
+package message
+
+import (
+	"errors"
+	"io"
+
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// Flags represents the possible PSS message flags
+type Flags struct {
+	Raw       bool // message is flagged as raw or with external encryption
+	Symmetric bool // message is symmetrically encrypted
+}
+
+const flagsLength = 1
+const flagSymmetric = 1 << 0
+const flagRaw = 1 << 1
+
+// ErrIncorrectFlagsFieldLength is returned when the incoming flags field length is incorrect
+var ErrIncorrectFlagsFieldLength = errors.New("Incorrect flags field length in message")
+
+// DecodeRLP implements the rlp.Decoder interface
+func (f *Flags) DecodeRLP(s *rlp.Stream) error {
+	flagsBytes, err := s.Bytes()
+	if err != nil {
+		return err
+	}
+	if len(flagsBytes) != flagsLength {
+		return ErrIncorrectFlagsFieldLength
+	}
+	f.Symmetric = flagsBytes[0]&flagSymmetric != 0
+	f.Raw = flagsBytes[0]&flagRaw != 0
+	return nil
+}
+
+// EncodeRLP implements the rlp.Encoder interface
+func (f *Flags) EncodeRLP(w io.Writer) error {
+	flagsBytes := []byte{0}
+	if f.Raw {
+		flagsBytes[0] |= flagRaw
+	}
+	if f.Symmetric {
+		flagsBytes[0] |= flagSymmetric
+	}
+
+	return rlp.Encode(w, flagsBytes)
+}

pss/internal/message/flags_test.go

@@ -0,0 +1,47 @@
+package message_test
+
+import (
+	"encoding/hex"
+	"fmt"
+	"testing"
+
+	"github.com/epiclabs-io/ut"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethersphere/swarm/pss/internal/message"
+)
+
+func TestFlags(tx *testing.T) {
+	t := ut.BeginTest(tx, false)
+	defer t.FinishTest()
+
+	bools := []bool{true, false}
+	for _, r := range bools {
+		for _, s := range bools {
+			f := message.Flags{
+				Symmetric: s,
+				Raw:       r,
+			}
+			// Test encoding:
+			bytes, err := rlp.EncodeToBytes(&f)
+			t.Ok(err)
+			t.EqualsKey(fmt.Sprintf("r=%t; s=%t", r, s), hex.EncodeToString(bytes))
+
+			// Test decoding:
+
+			var f2 message.Flags
+			err = rlp.DecodeBytes(bytes, &f2)
+			t.Ok(err)
+			t.Equals(f, f2)
+		}
+	}
+
+}
+
+func TestFlagsErrors(tx *testing.T) {
+	t := ut.BeginTest(tx, false)
+	defer t.FinishTest()
+
+	var f2 message.Flags
+	err := rlp.DecodeBytes([]byte{0x82, 0xFF, 0xFF}, &f2)
+	t.MustFailWith(err, message.ErrIncorrectFlagsFieldLength)
+}

pss/internal/message/testdata/TestFlags/results.json

@@ -0,0 +1,6 @@
+{
+	"r=false; s=false": "00",
+	"r=false; s=true": "01",
+	"r=true; s=false": "02",
+	"r=true; s=true": "03"
+}

pss/pss.go

@@ -37,6 +37,7 @@ import (
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/pot"
 	"github.com/ethersphere/swarm/pss/crypto"
+	"github.com/ethersphere/swarm/pss/internal/message"
 	"github.com/ethersphere/swarm/storage"
 	"golang.org/x/crypto/sha3"
 )
@@ -483,7 +484,7 @@ func (p *Pss) handle(ctx context.Context, msg interface{}) error {
 
 	// raw is simplest handler contingency to check, so check that first
 	var isRaw bool
-	if pssmsg.isRaw() {
+	if pssmsg.Flags.Raw {
 		if capabilities, ok := p.getTopicHandlerCaps(psstopic); ok {
 			if !capabilities.raw {
 				log.Debug("No handler for raw message", "topic", psstopic)
@@ -535,7 +536,7 @@ func (p *Pss) process(pssmsg *PssMsg, raw bool, prox bool) error {
 	if raw {
 		payload = pssmsg.Payload
 	} else {
-		if pssmsg.isSym() {
+		if pssmsg.Flags.Symmetric {
 			keyFunc = p.processSym
 		} else {
 			asymmetric = true
@@ -633,8 +634,8 @@ func (p *Pss) SendRaw(address PssAddress, topic Topic, msg []byte) error {
 		return err
 	}
 
-	pssMsgParams := &msgParams{
-		raw: true,
+	pssMsgParams := message.Flags{
+		Raw: true,
 	}
 
 	pssMsg := newPssMsg(pssMsgParams)
@@ -707,8 +708,8 @@ func (p *Pss) send(to []byte, topic Topic, msg []byte, asymmetric bool, key []by
 	log.Trace("pssmsg wrap done", "env", envelope, "mparams payload", hex.EncodeToString(msg), "to", hex.EncodeToString(to), "asym", asymmetric, "key", hex.EncodeToString(key))
 
 	// prepare for devp2p transport
-	pssMsgParams := &msgParams{
-		sym: !asymmetric,
+	pssMsgParams := message.Flags{
+		Symmetric: !asymmetric,
 	}
 	pssMsg := newPssMsg(pssMsgParams)
 	pssMsg.To = to

pss/pss_test.go

@@ -45,6 +45,7 @@ import (
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/pot"
 	"github.com/ethersphere/swarm/pss/crypto"
+	"github.com/ethersphere/swarm/pss/internal/message"
 	"github.com/ethersphere/swarm/state"
 	"github.com/ethersphere/swarm/testutil"
 )
@@ -118,29 +119,6 @@ func TestTopic(t *testing.T) {
 	}
 }
 
-// test bit packing of message control flags
-func TestMsgParams(t *testing.T) {
-	var ctrl byte
-	ctrl |= pssControlRaw
-	p := newMsgParamsFromBytes([]byte{ctrl})
-	m := newPssMsg(p)
-	if !m.isRaw() || m.isSym() {
-		t.Fatal("expected raw=true and sym=false")
-	}
-	ctrl |= pssControlSym
-	p = newMsgParamsFromBytes([]byte{ctrl})
-	m = newPssMsg(p)
-	if !m.isRaw() || !m.isSym() {
-		t.Fatal("expected raw=true and sym=true")
-	}
-	ctrl &= 0xff &^ pssControlRaw
-	p = newMsgParamsFromBytes([]byte{ctrl})
-	m = newPssMsg(p)
-	if m.isRaw() || !m.isSym() {
-		t.Fatal("expected raw=false and sym=true")
-	}
-}
-
 // test if we can insert into cache, match items with cache and cache expiry
 func TestCache(t *testing.T) {
 	var err error
@@ -361,7 +339,7 @@ func TestAddressMatchProx(t *testing.T) {
 
 	// first the unit test on the method that calculates possible receipient using prox
 	for i, distance := range remoteDistances {
-		pssMsg := newPssMsg(&msgParams{})
+		pssMsg := newPssMsg(message.Flags{})
 		pssMsg.To = make([]byte, len(localAddr))
 		copy(pssMsg.To, localAddr)
 		var byteIdx = distance / 8
@@ -401,7 +379,7 @@ func TestAddressMatchProx(t *testing.T) {
 
 		var data [32]byte
 		rand.Read(data[:])
-		pssMsg := newPssMsg(&msgParams{raw: true})
+		pssMsg := newPssMsg(message.Flags{Raw: true})
 		pssMsg.To = remoteAddr
 		pssMsg.Expire = uint32(time.Now().Unix() + 4200)
 		pssMsg.Payload = data[:]
@@ -430,7 +408,7 @@ func TestAddressMatchProx(t *testing.T) {
 
 		var data [32]byte
 		rand.Read(data[:])
-		pssMsg := newPssMsg(&msgParams{raw: true})
+		pssMsg := newPssMsg(message.Flags{Raw: true})
 		pssMsg.To = remoteAddr
 		pssMsg.Expire = uint32(time.Now().Unix() + 4200)
 		pssMsg.Payload = data[:]
@@ -452,7 +430,7 @@ func TestAddressMatchProx(t *testing.T) {
 		remotePotAddr := pot.RandomAddressAt(localPotAddr, distance)
 		remoteAddr := remotePotAddr.Bytes()
 
-		pssMsg := newPssMsg(&msgParams{raw: true})
+		pssMsg := newPssMsg(message.Flags{Raw: true})
 		pssMsg.To = remoteAddr
 		pssMsg.Expire = uint32(time.Now().Unix() + 4200)
 		pssMsg.Payload = []byte(remotePotAddr.String())
@@ -791,8 +769,8 @@ func TestRawAllow(t *testing.T) {
 	ps.Register(&topic, hndlrNoRaw)
 
 	// test it with a raw message, should be poo-poo
-	pssMsg := newPssMsg(&msgParams{
-		raw: true,
+	pssMsg := newPssMsg(message.Flags{
+		Raw: true,
 	})
 	pssMsg.To = baseAddr.OAddr
 	pssMsg.Expire = uint32(time.Now().Unix() + 4200)
@@ -1694,7 +1672,7 @@ func benchmarkSymkeyBruteforceSameaddr(b *testing.B) {
 func testRandomMessage() *PssMsg {
 	addr := make([]byte, 32)
 	addr[0] = 0x01
-	msg := newPssMsg(&msgParams{})
+	msg := newPssMsg(message.Flags{})
 	msg.To = addr
 	msg.Expire = uint32(time.Now().Add(time.Second * 60).Unix())
 	msg.Topic = [4]byte{}

pss/types.go

@@ -26,13 +26,12 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethersphere/swarm/pss/internal/message"
 	"github.com/ethersphere/swarm/storage"
 )
 
 const (
-	pssControlSym = 1
-	pssControlRaw = 1 << 1
-	TopicLength   = 4 // in bytes Taken from Whisper
+	TopicLength = 4 // in bytes Taken from Whisper
 )
 
 var (
@@ -86,34 +85,6 @@ func (a *PssAddress) UnmarshalJSON(input []byte) error {
 // holds the digest of a message used for caching
 type digest [digestLength]byte
 
-// conceals bitwise operations on the control flags byte
-type msgParams struct {
-	raw bool
-	sym bool
-}
-
-func newMsgParamsFromBytes(paramBytes []byte) *msgParams {
-	if len(paramBytes) != 1 {
-		return nil
-	}
-	return &msgParams{
-		raw: paramBytes[0]&pssControlRaw > 0,
-		sym: paramBytes[0]&pssControlSym > 0,
-	}
-}
-
-func (m *msgParams) Bytes() (paramBytes []byte) {
-	var b byte
-	if m.raw {
-		b |= pssControlRaw
-	}
-	if m.sym {
-		b |= pssControlSym
-	}
-	paramBytes = append(paramBytes, b)
-	return paramBytes
-}
-
 type outboxMsg struct {
 	msg       *PssMsg
 	startedAt time.Time
@@ -129,28 +100,18 @@ func newOutboxMsg(msg *PssMsg) *outboxMsg {
 // PssMsg encapsulates messages transported over pss.
 type PssMsg struct {
 	To      []byte
-	Control []byte
+	Flags   message.Flags
 	Expire  uint32
 	Topic   Topic
 	Payload []byte
 }
 
-func newPssMsg(param *msgParams) *PssMsg {
+func newPssMsg(flags message.Flags) *PssMsg {
 	return &PssMsg{
-		Control: param.Bytes(),
+		Flags: flags,
 	}
 }
 
-// message is flagged as raw / external encryption
-func (msg *PssMsg) isRaw() bool {
-	return msg.Control[0]&pssControlRaw > 0
-}
-
-// message is flagged as symmetrically encrypted
-func (msg *PssMsg) isSym() bool {
-	return msg.Control[0]&pssControlSym > 0
-}
-
 // serializes the message for use in cache
 func (msg *PssMsg) serialize() []byte {
 	rlpdata, _ := rlp.EncodeToBytes(struct {