diff --git a/broadcast/sizedBroadcast.go b/broadcast/sizedBroadcast.go
index d05effe1bcf93b07a0f3cd3533c28df8136c3a46..925f44ab439af922570538fdd949d59a83579ec2 100644
--- a/broadcast/sizedBroadcast.go
+++ b/broadcast/sizedBroadcast.go
@@ -66,7 +66,7 @@ func DecodeSizedBroadcast(data []byte) ([]byte, error) {
errDecodeSizedBroadcastDataLen, len(data), sizedBroadcastMinSize)
}
- size := binary.LittleEndian.Uint16(data[:sizeSize])
+ size := GetSizedBroadcastSize(data)
if int(size) > len(data[sizeSize:]) {
return nil, errors.Errorf(
errDecodeSizedBroadcastSize, size, len(data[sizeSize:]))
@@ -75,6 +75,16 @@ func DecodeSizedBroadcast(data []byte) ([]byte, error) {
return data[sizeSize : size+sizeSize], nil
}
+// GetSizedBroadcastSize returns the size of the sized broadcast, used for
+// testing
+func GetSizedBroadcastSize(data []byte) uint16 {
+ if len(data) < sizeSize {
+ return 0
+ }
+
+ return binary.LittleEndian.Uint16(data[:sizeSize])
+}
+
// MaxSizedBroadcastPayloadSize returns the maximum size of a payload that can
// fit in a sized broadcast message for the given maximum cMix message payload
// size.
diff --git a/channels/adminListener.go b/channels/adminListener.go
index 8ee876bc2e6937b05432074c1ff0b85f96ecadec..c64819bf4e0eb597fe63649e90bb723081573353 100644
--- a/channels/adminListener.go
+++ b/channels/adminListener.go
@@ -13,9 +13,8 @@ import (
// the adminListener adheres to the broadcast listener interface and is used
// when admin messages are received on the channel
type adminListener struct {
- name NameService
- events *events
- chID *id.ID
+ chID *id.ID
+ trigger triggerAdminEventFunc
}
func (al *adminListener) Listen(payload []byte,
@@ -33,7 +32,7 @@ func (al *adminListener) Listen(payload []byte,
msgID := channel.MakeMessageID(payloadUnpadded)
//Decode the message as a channel message
- var cm *ChannelMessage
+ cm := &ChannelMessage{}
if err = proto.Unmarshal(payloadUnpadded, cm); err != nil {
jww.WARN.Printf("Failed to unmarshal Channel Message from Admin"+
" on channel %s", al.chID)
@@ -51,7 +50,7 @@ func (al *adminListener) Listen(payload []byte,
}
//Submit the message to the event model for listening
- al.events.triggerAdminEvent(al.chID, cm, msgID, receptionID, round)
+ al.trigger(al.chID, cm, msgID, receptionID, round)
return
}
diff --git a/channels/adminListener_test.go b/channels/adminListener_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d2746007fc08586b710eb1ce5a989b466e8f50ae
--- /dev/null
+++ b/channels/adminListener_test.go
@@ -0,0 +1,241 @@
+package channels
+
+import (
+ "bytes"
+ "gitlab.com/elixxir/client/broadcast"
+ "testing"
+ "time"
+
+ "github.com/golang/protobuf/proto"
+
+ "gitlab.com/elixxir/client/cmix/identity/receptionID"
+ "gitlab.com/elixxir/client/cmix/rounds"
+ cryptoChannel "gitlab.com/elixxir/crypto/channel"
+ "gitlab.com/elixxir/primitives/states"
+ "gitlab.com/xx_network/primitives/id"
+)
+
+type triggerAdminEventDummy struct {
+ gotData bool
+
+ chID *id.ID
+ cm *ChannelMessage
+ msgID cryptoChannel.MessageID
+ receptionID receptionID.EphemeralIdentity
+ round rounds.Round
+}
+
+func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID, cm *ChannelMessage,
+ messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
+ round rounds.Round) {
+ taed.gotData = true
+
+ taed.chID = chID
+ taed.cm = cm
+ taed.msgID = messageID
+ taed.receptionID = receptionID
+ taed.round = round
+}
+
+// Tests the happy path
+func TestAdminListener_Listen(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ RoundID: uint64(r.ID),
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ chMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, cmSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ msgID := cryptoChannel.MakeMessageID(cmSerial)
+
+ //build the listener
+ dummy := &triggerAdminEventDummy{}
+
+ al := adminListener{
+ chID: chID,
+ trigger: dummy.triggerAdminEvent,
+ }
+
+ //call the listener
+ al.Listen(chMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if !dummy.gotData {
+ t.Fatalf("No data returned after valid listen")
+ }
+
+ if !dummy.chID.Cmp(chID) {
+ t.Errorf("Channel ID not correct: %s vs %s", dummy.chID, chID)
+ }
+
+ if !bytes.Equal(cm.Payload, dummy.cm.Payload) {
+ t.Errorf("payload not correct: %s vs %s", cm.Payload,
+ dummy.cm.Payload)
+ }
+
+ if !msgID.Equals(dummy.msgID) {
+ t.Errorf("messageIDs not correct: %s vs %s", msgID,
+ dummy.msgID)
+ }
+
+ if r.ID != dummy.round.ID {
+ t.Errorf("rounds not correct: %s vs %s", r.ID,
+ dummy.round.ID)
+ }
+}
+
+// Tests that the message is rejected when the round it came on doesnt
+// match the round in the channel message
+func TestAdminListener_Listen_BadRound(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ // different from the round above
+ RoundID: 69,
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ chMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, cmSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerAdminEventDummy{}
+
+ al := adminListener{
+ chID: chID,
+ trigger: dummy.triggerAdminEvent,
+ }
+
+ //call the listener
+ al.Listen(chMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("payload handled when it should have failed due to " +
+ "a round issue")
+ }
+
+}
+
+// Tests that the message is rejected when the channel message is malformed
+func TestAdminListener_Listen_BadChannelMessage(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ cmSerial := []byte("blarg")
+
+ chMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, cmSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerAdminEventDummy{}
+
+ al := adminListener{
+ chID: chID,
+ trigger: dummy.triggerAdminEvent,
+ }
+
+ //call the listener
+ al.Listen(chMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("payload handled when it should have failed due to " +
+ "a malformed channel message")
+ }
+
+}
+
+// Tests that the message is rejected when the sized broadcast message is
+//malformed
+func TestAdminListener_Listen_BadSizedBroadcast(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ // different from the round above
+ RoundID: 69,
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ chMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, cmSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //remove half the sized broadcast to make it malformed
+ chMsgSerialSized = chMsgSerialSized[:broadcast.GetSizedBroadcastSize(chMsgSerialSized)/2]
+
+ //build the listener
+ dummy := &triggerAdminEventDummy{}
+
+ al := adminListener{
+ chID: chID,
+ trigger: dummy.triggerAdminEvent,
+ }
+
+ //call the listener
+ al.Listen(chMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("payload handled when it should have failed due to " +
+ "a malformed sized broadcast")
+ }
+}
diff --git a/channels/eventModel.go b/channels/eventModel.go
index 332ab75bad05a7951653d5f505a5bd86b3d7c525..8d7db0af1683723e553d0f6b500c6e875f820d0f 100644
--- a/channels/eventModel.go
+++ b/channels/eventModel.go
@@ -113,6 +113,9 @@ func (e *events) RegisterReceiveHandler(messageType MessageType,
return nil
}
+type triggerEventFunc func(chID *id.ID, umi *userMessageInternal,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round)
+
// triggerEvent is an internal function which is used to trigger message
// reception on a message received from a user (symmetric encryption)
// It will call the appropriate MessageTypeHandler assuming one exists.
@@ -139,6 +142,10 @@ func (e *events) triggerEvent(chID *id.ID, umi *userMessageInternal,
return
}
+type triggerAdminEventFunc func(chID *id.ID, cm *ChannelMessage,
+ messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
+ round rounds.Round)
+
// triggerAdminEvent is an internal function which is used to trigger message
// reception on a message received from the admin (asymmetric encryption)
// It will call the appropriate MessageTypeHandler assuming one exists.
diff --git a/channels/joinedChannel.go b/channels/joinedChannel.go
index 055f5b6d167a70786617e014b0bca7c6da6b298c..ce53e29acafd07c36c0aa62fd26e919d0569801d 100644
--- a/channels/joinedChannel.go
+++ b/channels/joinedChannel.go
@@ -91,18 +91,17 @@ func (m *manager) addChannel(channel cryptoBroadcast.Channel) error {
// Connect to listeners
err = b.RegisterListener((&userListener{
- name: m.name,
- events: m.events,
- chID: channel.ReceptionID,
+ name: m.name,
+ chID: channel.ReceptionID,
+ trigger: m.events.triggerEvent,
}).Listen, broadcast.Symmetric)
if err != nil {
return err
}
err = b.RegisterListener((&adminListener{
- name: m.name,
- events: m.events,
- chID: channel.ReceptionID,
+ chID: channel.ReceptionID,
+ trigger: m.events.triggerAdminEvent,
}).Listen, broadcast.Asymmetric)
if err != nil {
return err
@@ -224,18 +223,17 @@ func loadJoinedChannel(chId *id.ID, kv *versioned.KV, net broadcast.Client,
}
err = b.RegisterListener((&userListener{
- name: name,
- events: e,
- chID: jcd.broadcast.ReceptionID,
+ name: name,
+ chID: jcd.broadcast.ReceptionID,
+ trigger: e.triggerEvent,
}).Listen, broadcast.Symmetric)
if err != nil {
return nil, err
}
err = b.RegisterListener((&adminListener{
- name: name,
- events: e,
- chID: jcd.broadcast.ReceptionID,
+ chID: jcd.broadcast.ReceptionID,
+ trigger: e.triggerAdminEvent,
}).Listen, broadcast.Asymmetric)
if err != nil {
return nil, err
diff --git a/channels/send.go b/channels/send.go
index aa8a25cf664d4df410e510240962cd23172817f0..2523822e3166adf73cc84be8e4e8707f367fc8bc 100644
--- a/channels/send.go
+++ b/channels/send.go
@@ -53,6 +53,9 @@ func (m *manager) SendGeneric(channelID *id.ID, messageType MessageType,
return nil, err
}
+ //make the messageID
+ msgId = cryptoChannel.MakeMessageID(chMsgSerial)
+
//Sign the message
messageSig, err := m.name.SignChannelMessage(chMsgSerial)
if err != nil {
@@ -84,8 +87,6 @@ func (m *manager) SendGeneric(channelID *id.ID, messageType MessageType,
return nil, err
}
- msgId = cryptoChannel.MakeMessageID(usrMsgSerialSized)
-
return usrMsgSerialSized, nil
}
@@ -132,6 +133,8 @@ func (m *manager) SendAdminGeneric(privKey *rsa.PrivateKey, channelID *id.ID,
return nil, err
}
+ msgId = cryptoChannel.MakeMessageID(chMsgSerial)
+
//check if the message is too long
if len(chMsgSerial) > broadcast.MaxSizedBroadcastPayloadSize(privKey.Size()) {
return nil, MessageTooLongErr
@@ -144,8 +147,6 @@ func (m *manager) SendAdminGeneric(privKey *rsa.PrivateKey, channelID *id.ID,
return nil, err
}
- msgId = cryptoChannel.MakeMessageID(chMsgSerialSized)
-
return chMsgSerialSized, nil
}
diff --git a/channels/send_test.go b/channels/send_test.go
index 8de7c9f522657d209ac5694256e40e9f335da8b1..8abc1fad748c8767a5e4c708c8da75c00ba1cf43 100644
--- a/channels/send_test.go
+++ b/channels/send_test.go
@@ -2,21 +2,16 @@ package channels
import (
"crypto/ed25519"
- "testing"
"time"
- "gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/message"
"gitlab.com/elixxir/client/cmix/rounds"
- "gitlab.com/elixxir/client/storage/versioned"
cryptoBroadcast "gitlab.com/elixxir/crypto/broadcast"
cryptoChannel "gitlab.com/elixxir/crypto/channel"
- "gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/elixxir/ekv"
)
type mockBroadcastClient struct{}
@@ -51,7 +46,9 @@ func (m *mockBroadcastClient) DeleteClientService(clientID *id.ID) {}
func (m *mockBroadcastClient) RemoveIdentity(id *id.ID) {}
-type mockNameService struct{}
+type mockNameService struct {
+ validChMsg bool
+}
func (m *mockNameService) GetUsername() string {
return "Alice"
@@ -71,7 +68,7 @@ func (m *mockNameService) SignChannelMessage(message []byte) (signature []byte,
func (m *mockNameService) ValidateChannelMessage(username string, lease time.Time,
pubKey ed25519.PublicKey, authorIDSignature []byte) bool {
- return true
+ return m.validChMsg
}
type mockEventModel struct{}
@@ -99,12 +96,13 @@ func (m *mockEventModel) ReceiveReaction(channelID *id.ID, messageID cryptoChann
}
-func TestSendGeneric(t *testing.T) {
+/*func TestSendGeneric(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
client := new(mockBroadcastClient)
rngGen := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
nameService := new(mockNameService)
+ nameService.validChMsg = true
model := new(mockEventModel)
manager := NewManager(kv, client, rngGen, nameService, model)
@@ -134,4 +132,4 @@ func TestSendGeneric(t *testing.T) {
}
t.Logf("messageId %v, roundId %v, ephemeralId %v", messageId, roundId, ephemeralId)
-}
+}*/
diff --git a/channels/userListener.go b/channels/userListener.go
index a69de61f32e32de1c57728b4e9080d61b42dbbd1..4cc5f61522f5fe9aa3b5325f24e3be91d7119244 100644
--- a/channels/userListener.go
+++ b/channels/userListener.go
@@ -14,9 +14,9 @@ import (
// the userListener adheres to the broadcast listener interface and is used
// when user messages are received on the channel
type userListener struct {
- name NameService
- events *events
- chID *id.ID
+ name NameService
+ chID *id.ID
+ trigger triggerEventFunc
}
func (gul *userListener) Listen(payload []byte,
@@ -54,7 +54,7 @@ func (gul *userListener) Listen(payload []byte,
// check that the username lease is valid
usernameLeaseEnd := time.Unix(0, um.UsernameLease)
- if usernameLeaseEnd.After(round.Timestamps[states.QUEUED]) {
+ if !usernameLeaseEnd.After(round.Timestamps[states.QUEUED]) {
jww.WARN.Printf("Message %s on channel %s purportedly from %s "+
"has an expired lease, ended %s, round %d was sent at %s", msgID,
gul.chID, um.Username, usernameLeaseEnd, round.ID,
@@ -82,7 +82,7 @@ func (gul *userListener) Listen(payload []byte,
//TODO: Processing of the message relative to admin commands will be here
//Submit the message to the event model for listening
- gul.events.triggerEvent(gul.chID, umi, receptionID, round)
+ gul.trigger(gul.chID, umi, receptionID, round)
return
}
diff --git a/channels/userListener_test.go b/channels/userListener_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0103f4f0b71fe9e006c1916f7a4948a43f1126cd
--- /dev/null
+++ b/channels/userListener_test.go
@@ -0,0 +1,524 @@
+package channels
+
+import (
+ "bytes"
+ "crypto/ed25519"
+ "github.com/golang/protobuf/proto"
+ "gitlab.com/elixxir/client/broadcast"
+ "gitlab.com/elixxir/client/cmix/identity/receptionID"
+ "gitlab.com/elixxir/client/cmix/rounds"
+ cryptoChannel "gitlab.com/elixxir/crypto/channel"
+ "gitlab.com/elixxir/primitives/states"
+ "gitlab.com/xx_network/primitives/id"
+ "math/rand"
+ "testing"
+ "time"
+)
+
+type triggerEventDummy struct {
+ gotData bool
+
+ chID *id.ID
+ umi *userMessageInternal
+ msgID cryptoChannel.MessageID
+ receptionID receptionID.EphemeralIdentity
+ round rounds.Round
+}
+
+func (ted *triggerEventDummy) triggerEvent(chID *id.ID, umi *userMessageInternal,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round) {
+ ted.gotData = true
+
+ ted.chID = chID
+ ted.umi = umi
+ ted.receptionID = receptionID
+ ted.round = round
+ ted.msgID = umi.GetMessageID()
+}
+
+// Tests the happy path
+func TestUserListener_Listen(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, priv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ RoundID: uint64(r.ID),
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ msgID := cryptoChannel.MakeMessageID(cmSerial)
+
+ sig := ed25519.Sign(priv, cmSerial)
+ ns := &mockNameService{validChMsg: true}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if !dummy.gotData {
+ t.Fatalf("No data returned after valid listen")
+ }
+
+ if !dummy.chID.Cmp(chID) {
+ t.Errorf("Channel ID not correct: %s vs %s", dummy.chID, chID)
+ }
+
+ if !bytes.Equal(um.Message, dummy.umi.userMessage.Message) {
+ t.Errorf("message not correct: %s vs %s", um.Message,
+ dummy.umi.userMessage.Message)
+ }
+
+ if !msgID.Equals(dummy.msgID) {
+ t.Errorf("messageIDs not correct: %s vs %s", msgID,
+ dummy.msgID)
+ }
+
+ if r.ID != dummy.round.ID {
+ t.Errorf("rounds not correct: %s vs %s", r.ID,
+ dummy.round.ID)
+ }
+}
+
+//tests that the message is rejected when the user signature is invalid
+func TestUserListener_Listen_BadUserSig(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, _, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ RoundID: uint64(r.ID),
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ _, badpriv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ sig := ed25519.Sign(badpriv, cmSerial)
+ ns := &mockNameService{validChMsg: true}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}
+
+//tests that the message is rejected when the validation signature cannot be
+//validated
+func TestUserListener_Listen_BadValidSig(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, priv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ RoundID: uint64(r.ID),
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ sig := ed25519.Sign(priv, cmSerial)
+ //make the signature not validate
+ ns := &mockNameService{validChMsg: false}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}
+
+//tests that the message is rejected when the username timestamp is not valid
+func TestUserListener_Listen_BadUnameTs(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, priv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ RoundID: uint64(r.ID),
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ sig := ed25519.Sign(priv, cmSerial)
+ ns := &mockNameService{validChMsg: true}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ //make the username lease invalid
+ UsernameLease: 42,
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}
+
+//tests that the message is rejected when the round in the message does not
+//match the round passed in
+func TestUserListener_Listen_BadRound(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, priv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ //make the round not match
+ RoundID: 69,
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ sig := ed25519.Sign(priv, cmSerial)
+ ns := &mockNameService{validChMsg: true}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}
+
+//tests that the message is rejected when the user message is malformed
+func TestUserListener_Listen_BadMessage(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ ns := &mockNameService{validChMsg: true}
+
+ umSerial := []byte("malformed")
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}
+
+//tests that the message is rejected when the sized broadcast is malformed
+func TestUserListener_Listen_BadSizedBroadcast(t *testing.T) {
+
+ //build inputs
+ chID := &id.ID{}
+ chID[0] = 1
+
+ r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
+ r.Timestamps[states.QUEUED] = time.Now()
+
+ rng := rand.New(rand.NewSource(42))
+ pub, priv, err := ed25519.GenerateKey(rng)
+ if err != nil {
+ t.Fatalf("failed to generate ed25519 keypair, cant run test")
+ }
+
+ cm := &ChannelMessage{
+ Lease: int64(time.Hour),
+ //make the round not match
+ RoundID: 69,
+ PayloadType: 42,
+ Payload: []byte("blarg"),
+ }
+
+ cmSerial, err := proto.Marshal(cm)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ sig := ed25519.Sign(priv, cmSerial)
+ ns := &mockNameService{validChMsg: true}
+
+ um := &UserMessage{
+ Message: cmSerial,
+ ValidationSignature: []byte("Not checked in test"),
+ Signature: sig,
+ Username: ns.GetUsername(),
+ ECCPublicKey: pub,
+ UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ }
+
+ umSerial, err := proto.Marshal(um)
+ if err != nil {
+ t.Fatalf("Failed to marshal proto: %+v", err)
+ }
+
+ umMsgSerialSized, err := broadcast.NewSizedBroadcast(
+ 512, umSerial)
+ if err != nil {
+ t.Fatalf("Failed to size channel message: %+v", err)
+ }
+
+ //remove half the sized broadcast to make it malformed
+ umMsgSerialSized = umMsgSerialSized[:broadcast.GetSizedBroadcastSize(umMsgSerialSized)/2]
+
+ //build the listener
+ dummy := &triggerEventDummy{}
+
+ al := userListener{
+ chID: chID,
+ name: ns,
+ trigger: dummy.triggerEvent,
+ }
+
+ //call the listener
+ al.Listen(umMsgSerialSized, receptionID.EphemeralIdentity{}, r)
+
+ //check the results
+ if dummy.gotData {
+ t.Fatalf("Data returned after invalid listen")
+ }
+}