Initial peer scoring implementation to detect problematic nodes

cmd/pineconesim/simulator/adversary/drop_packets.go

@@ -94,6 +94,10 @@ func defaultFrameCount() PeerFrameCount {
 	frameCount[types.TypeVirtualSnakeTeardown] = atomic.NewUint64(0)
 	frameCount[types.TypeTreeRouted] = atomic.NewUint64(0)
 	frameCount[types.TypeVirtualSnakeRouted] = atomic.NewUint64(0)
+	frameCount[types.TypeTreePing] = atomic.NewUint64(0)
+	frameCount[types.TypeTreePong] = atomic.NewUint64(0)
+	frameCount[types.TypeSNEKPing] = atomic.NewUint64(0)
+	frameCount[types.TypeSNEKPong] = atomic.NewUint64(0)
 
 	peerFrameCount := PeerFrameCount{
 		frameCount: frameCount,
@@ -123,8 +127,8 @@ func NewAdversaryRouter(log *log.Logger, sk ed25519.PrivateKey, debug bool) *Adv
 	return adversary
 }
 
-func (a *AdversaryRouter) Subscribe(ch chan events.Event) {
-	a.rtr.Subscribe(ch)
+func (a *AdversaryRouter) Subscribe(ch chan events.Event) router.NodeState {
+	return a.rtr.Subscribe(ch)
 }
 
 func (a *AdversaryRouter) PublicKey() types.PublicKey {

cmd/pineconesim/simulator/commands.go

@@ -15,6 +15,7 @@
 package simulator
 
 import (
+	"crypto/ed25519"
 	"fmt"
 	"log"
 	"strconv"
@@ -47,6 +48,8 @@ func UnmarshalCommandJSON(command *SimCommandMsg) (SimCommand, error) {
 	case SimAddNode:
 		name := ""
 		nodeType := UnknownType
+		privKeyStr := ""
+		var privKey *ed25519.PrivateKey = nil
 		if val, ok := command.Event.(map[string]interface{})["Name"]; ok {
 			name = val.(string)
 		} else {
@@ -58,7 +61,16 @@ func UnmarshalCommandJSON(command *SimCommandMsg) (SimCommand, error) {
 		} else {
 			err = fmt.Errorf("%sAddNode.NodeType field doesn't exist", FAILURE_PREAMBLE)
 		}
-		msg = AddNode{name, nodeType}
+
+		if val, ok := command.Event.(map[string]interface{})["PrivKey"]; ok {
+			privKeyStr = val.(string)
+			if len(privKeyStr) == ed25519.PrivateKeySize {
+				newPrivKey := ed25519.PrivateKey{}
+				copy(newPrivKey[:], privKeyStr)
+				privKey = &newPrivKey
+			}
+		}
+		msg = AddNode{name, nodeType, privKey}
 	case SimRemoveNode:
 		name := ""
 		if val, ok := command.Event.(map[string]interface{})["Name"]; ok {
@@ -315,21 +327,29 @@ func (c Delay) String() string {
 type AddNode struct {
 	Node     string
 	NodeType APINodeType
+	PrivKey  *ed25519.PrivateKey
 }
 
 // Tag AddNode as a Command
 func (c AddNode) Run(log *log.Logger, sim *Simulator) {
 	log.Printf("Executing command %s", c)
-	if err := sim.CreateNode(c.Node, c.NodeType); err != nil {
-		log.Printf("Failed creating new node %s: %s", c.Node, err)
-		return
+	if c.PrivKey != nil {
+		if err := sim.CreateNodeWithKey(c.Node, c.NodeType, *c.PrivKey); err != nil {
+			log.Printf("Failed creating new node %s: %s", c.Node, err)
+			return
+		}
+	} else {
+		if err := sim.CreateNode(c.Node, c.NodeType); err != nil {
+			log.Printf("Failed creating new node %s: %s", c.Node, err)
+			return
+		}
 	}
 
 	sim.StartNodeEventHandler(c.Node, c.NodeType)
 }
 
 func (c AddNode) String() string {
-	return fmt.Sprintf("AddNode{Name:%s}", c.Node)
+	return fmt.Sprintf("AddNode{Name:%s, Type:%d, Private Key:%v}", c.Node, c.NodeType, c.PrivKey)
 }
 
 type RemoveNode struct {

cmd/pineconesim/simulator/events.go

@@ -20,6 +20,11 @@ type SimEvent interface {
 	isEvent()
 }
 
+type NullEvent struct{}
+
+// Tag NullEvent as an Event
+func (e NullEvent) isEvent() {}
+
 type NodeAdded struct {
 	Node      string
 	PublicKey string

cmd/pineconesim/simulator/interface.go

@@ -36,11 +36,13 @@ func (sim *Simulator) ReportDistance(a, b string, l int64, snek bool) {
 		sim.dists[a][b].ObservedTree = l
 	}
 	if sim.dists[a][b].Real == 0 {
-		na, _ := sim.graph.GetMapping(a)
-		nb, _ := sim.graph.GetMapping(b)
-		path, err := sim.graph.Shortest(na, nb)
-		if err == nil {
-			sim.dists[a][b].Real = path.Distance
+		if sim.graph != nil {
+			na, _ := sim.graph.GetMapping(a)
+			nb, _ := sim.graph.GetMapping(b)
+			path, err := sim.graph.Shortest(na, nb)
+			if err == nil {
+				sim.dists[a][b].Real = path.Distance
+			}
 		}
 	}
 }

cmd/pineconesim/simulator/nodes.go

@@ -35,6 +35,15 @@ func (sim *Simulator) Node(t string) *Node {
 }
 
 func (sim *Simulator) CreateNode(t string, nodeType APINodeType) error {
+	_, sk, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		return fmt.Errorf("ed25519.GenerateKey: %w", err)
+	}
+
+	return sim.CreateNodeWithKey(t, nodeType, sk)
+}
+
+func (sim *Simulator) CreateNodeWithKey(t string, nodeType APINodeType, privKey ed25519.PrivateKey) error {
 	if _, ok := sim.nodes[t]; ok {
 		return fmt.Errorf("%s already exists!", t)
 	}
@@ -56,16 +65,12 @@ func (sim *Simulator) CreateNode(t string, nodeType APINodeType) error {
 			return fmt.Errorf("net.Listen: %w", err)
 		}
 	}
-	_, sk, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		return fmt.Errorf("ed25519.GenerateKey: %w", err)
-	}
 	crc := crc32.ChecksumIEEE([]byte(t))
 	color := 31 + (crc % 6)
 	logger := log.New(sim.log.Writer(), fmt.Sprintf("\033[%dmNode %s:\033[0m ", color, t), 0)
 
 	n := &Node{
-		SimRouter:  sim.routerCreationMap[nodeType](logger, sk, true),
+		SimRouter:  sim.routerCreationMap[nodeType](logger, privKey, true),
 		l:          l,
 		ListenAddr: tcpaddr,
 	}
@@ -118,14 +123,14 @@ func (sim *Simulator) StartNodeEventHandler(t string, nodeType APINodeType) {
 	ch := make(chan events.Event)
 	handler := eventHandler{node: t, ch: ch}
 	quit := make(chan bool)
-	go handler.Run(quit, sim)
-	sim.nodes[t].Subscribe(ch)
+	nodeState := sim.nodes[t].Subscribe(ch)
 
 	sim.nodeRunnerChannelsMutex.Lock()
 	sim.nodeRunnerChannels[t] = append(sim.nodeRunnerChannels[t], quit)
 	sim.nodeRunnerChannelsMutex.Unlock()
 
-	phony.Block(sim.State, func() { sim.State._addNode(t, sim.nodes[t].PublicKey().String(), nodeType) })
+	phony.Block(sim.State, func() { sim.State._addNode(t, sim.nodes[t].PublicKey().String(), nodeType, nodeState) })
+	go handler.Run(quit, sim)
 }
 
 func (sim *Simulator) RemoveNode(node string) {

cmd/pineconesim/simulator/pathfind.go

@@ -70,6 +70,7 @@ func (sim *Simulator) PingSNEK(from, to string) (uint16, time.Duration, error) {
 	}
 
 	success = true
+	sim.log.Printf("Successful ping from %s to %s", from, to)
 	sim.ReportDistance(from, to, int64(hops), true)
 	return hops, rtt, nil
 }

cmd/pineconesim/simulator/router.go

@@ -29,7 +29,7 @@ import (
 type SimRouter interface {
 	PublicKey() types.PublicKey
 	Connect(conn net.Conn, options ...router.ConnectionOption) (types.SwitchPortID, error)
-	Subscribe(ch chan events.Event)
+	Subscribe(ch chan events.Event) router.NodeState
 	Ping(ctx context.Context, a net.Addr) (uint16, time.Duration, error)
 	Coords() types.Coordinates
 	ConfigureFilterDefaults(rates adversary.DropRates)
@@ -41,8 +41,8 @@ type DefaultRouter struct {
 	rtr *router.Router
 }
 
-func (r *DefaultRouter) Subscribe(ch chan events.Event) {
-	r.rtr.Subscribe(ch)
+func (r *DefaultRouter) Subscribe(ch chan events.Event) router.NodeState {
+	return r.rtr.Subscribe(ch)
 }
 
 func (r *DefaultRouter) PublicKey() types.PublicKey {

cmd/pineconesim/simulator/simulator.go

@@ -217,6 +217,9 @@ func (sim *Simulator) handleTreeRootAnnUpdate(node string, root string, sequence
 	rootName := ""
 	if peerNode, err := sim.State.GetNodeName(root); err == nil {
 		rootName = peerNode
+	} else {
+		log.Printf("Cannot convert %s to root for %s", root, node)
+		rootName = "UNKNOWN"
 	}
 	sim.State.Act(nil, func() { sim.State._updateTreeRootAnnouncement(node, rootName, sequence, time, coords) })
 }

cmd/pineconesim/simulator/state.go

@@ -19,6 +19,7 @@ import (
 	"reflect"
 
 	"github.com/Arceliar/phony"
+	"github.com/matrix-org/pinecone/router"
 )
 
 type RootAnnouncement struct {
@@ -148,13 +149,7 @@ func (s *StateAccessor) GetNodeName(peerID string) (string, error) {
 	node := ""
 	err := fmt.Errorf("Provided peerID is not associated with a known node")
 
-	phony.Block(s, func() {
-		for k, v := range s._state.Nodes {
-			if v.PeerID == peerID {
-				node, err = k, nil
-			}
-		}
-	})
+	phony.Block(s, func() { node, err = s._getNodeName(peerID) })
 	return node, err
 }
 
@@ -169,8 +164,54 @@ func (s *StateAccessor) GetNodeCoords(name string) []uint64 {
 	return coords
 }
 
-func (s *StateAccessor) _addNode(name string, peerID string, nodeType APINodeType) {
+func (s *StateAccessor) _getNodeName(peerID string) (string, error) {
+	node := ""
+	err := fmt.Errorf("Provided peerID is not associated with a known node")
+
+	for k, v := range s._state.Nodes {
+		if v.PeerID == peerID {
+			node, err = k, nil
+		}
+	}
+
+	return node, err
+}
+
+func (s *StateAccessor) _addNode(name string, peerID string, nodeType APINodeType, nodeState router.NodeState) {
 	s._state.Nodes[name] = NewNodeState(peerID, nodeType)
+	if peernode, err := s._getNodeName(nodeState.Parent); err == nil {
+		s._state.Nodes[name].Parent = peernode
+	}
+	connections := map[int]string{}
+	for i, node := range nodeState.Connections {
+		if i == 0 {
+			// NOTE : Skip connection on port 0 since it is the loopback port
+			continue
+		}
+		if peernode, err := s._getNodeName(node); err == nil {
+			connections[i] = peernode
+		}
+	}
+	s._state.Nodes[name].Connections = connections
+	s._state.Nodes[name].Coords = nodeState.Coords
+	root := ""
+	if peernode, err := s._getNodeName(nodeState.Announcement.RootPublicKey.String()); err == nil {
+		root = peernode
+	}
+	announcement := RootAnnouncement{
+		Root:     root,
+		Sequence: uint64(nodeState.Announcement.RootSequence),
+		Time:     nodeState.AnnouncementTime,
+	}
+	s._state.Nodes[name].Announcement = announcement
+	if peernode, err := s._getNodeName(nodeState.AscendingPeer); err == nil {
+		s._state.Nodes[name].AscendingPeer = peernode
+	}
+	s._state.Nodes[name].AscendingPathID = nodeState.AscendingPathID
+	if peernode, err := s._getNodeName(nodeState.DescendingPeer); err == nil {
+		s._state.Nodes[name].DescendingPeer = peernode
+	}
+	s._state.Nodes[name].DescendingPathID = nodeState.DescendingPathID
 	s._publish(NodeAdded{Node: name, PublicKey: peerID, NodeType: int(nodeType)})
 }
 

router/api.go

@@ -42,11 +42,64 @@ type PeerInfo struct {
 	Zone      string
 }
 
+type NodeState struct {
+	PeerID           string
+	Connections      map[int]string
+	Parent           string
+	Coords           []uint64
+	Announcement     types.SwitchAnnouncement
+	AnnouncementTime uint64
+	AscendingPeer    string
+	AscendingPathID  string
+	DescendingPeer   string
+	DescendingPathID string
+}
+
 // Subscribe registers a subscriber to this node's events
-func (r *Router) Subscribe(ch chan<- events.Event) {
+func (r *Router) Subscribe(ch chan<- events.Event) NodeState {
+	var stateCopy NodeState
 	phony.Block(r, func() {
 		r._subscribers[ch] = &phony.Inbox{}
+		stateCopy.PeerID = r.public.String()
+		connections := map[int]string{}
+		for _, p := range r.state._peers {
+			if p == nil {
+				continue
+			}
+			connections[int(p.port)] = p.public.String()
+		}
+		stateCopy.Connections = connections
+		parent := ""
+		if r.state._parent != nil {
+			parent = r.state._parent.public.String()
+		}
+		stateCopy.Parent = parent
+		coords := []uint64{}
+		for _, coord := range r.Coords() {
+			coords = append(coords, uint64(coord))
+		}
+		stateCopy.Coords = coords
+		announcement := r.state._rootAnnouncement()
+		stateCopy.Announcement = announcement.SwitchAnnouncement
+		stateCopy.AnnouncementTime = uint64(announcement.receiveTime.UnixNano())
+		asc := ""
+		ascPath := ""
+		if r.state._ascending != nil {
+			asc = r.state._ascending.PublicKey.String()
+			ascPath = hex.EncodeToString(r.state._ascending.PathID[:])
+		}
+		stateCopy.AscendingPeer = asc
+		stateCopy.AscendingPathID = ascPath
+		desc := ""
+		descPath := ""
+		if r.state._descending != nil {
+			desc = r.state._descending.PublicKey.String()
+			descPath = hex.EncodeToString(r.state._descending.PathID[:])
+		}
+		stateCopy.DescendingPeer = desc
+		stateCopy.DescendingPathID = descPath
 	})
+	return stateCopy
 }
 
 func (r *Router) Coords() types.Coordinates {