Merge branch 'retry' of cwtch.im/cwtch into master

app/app.go

@@ -113,7 +113,7 @@ func (app *application) CreatePeer(name string, password string) {
 	blockedPeers := profile.BlockedPeers()
 	// TODO: Would be nice if ProtocolEngine did not need to explicitly be given the Private Key.
 	identity := primitives.InitializeIdentity(profile.Name, &profile.Ed25519PrivateKey, &profile.Ed25519PublicKey)
-	engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, app.acn, app.eventBuses[profile.Onion], blockedPeers)
+	engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, app.acn, app.eventBuses[profile.Onion], profile.GetContacts(), blockedPeers)
 
 	app.peers[profile.Onion] = peer
 	app.engines[profile.Onion] = engine
@@ -168,7 +168,7 @@ func (app *application) LoadProfiles(password string) {
 
 		blockedPeers := profile.BlockedPeers()
 		identity := primitives.InitializeIdentity(profile.Name, &profile.Ed25519PrivateKey, &profile.Ed25519PublicKey)
-		engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, app.acn, app.eventBuses[profile.Onion], blockedPeers)
+		engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, app.acn, app.eventBuses[profile.Onion], profile.GetContacts(), blockedPeers)
 		app.mutex.Lock()
 		app.peers[profile.Onion] = peer
 		app.storage[profile.Onion] = profileStore

app/appService.go

@@ -96,7 +96,7 @@ func (as *applicationService) createPeer(name, password string) {
 	blockedPeers := profile.BlockedPeers()
 	// TODO: Would be nice if ProtocolEngine did not need to explicitly be given the Private Key.
 	identity := primitives.InitializeIdentity(profile.Name, &profile.Ed25519PrivateKey, &profile.Ed25519PublicKey)
-	engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, as.acn, as.eventBuses[profile.Onion], blockedPeers)
+	engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, as.acn, as.eventBuses[profile.Onion], profile.GetContacts(), blockedPeers)
 
 	as.storage[profile.Onion] = profileStore
 	as.engines[profile.Onion] = engine
@@ -112,7 +112,7 @@ func (as *applicationService) loadProfiles(password string) {
 
 		blockedPeers := profile.BlockedPeers()
 		identity := primitives.InitializeIdentity(profile.Name, &profile.Ed25519PrivateKey, &profile.Ed25519PublicKey)
-		engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, as.acn, as.eventBuses[profile.Onion], blockedPeers)
+		engine := connections.NewProtocolEngine(identity, profile.Ed25519PrivateKey, as.acn, as.eventBuses[profile.Onion], profile.GetContacts(), blockedPeers)
 		as.mutex.Lock()
 		as.storage[profile.Onion] = profileStore
 		as.engines[profile.Onion] = engine

app/plugins/contactRetry.go

@@ -57,7 +57,7 @@ func (cr *contactRetry) run() {
 					p.ticks++
 					if p.ticks == p.backoff {
 						p.ticks = 0
-						cr.bus.Publish(event.NewEvent(event.PeerRequest, map[event.Field]string{event.RemotePeer: p.id}))
+						cr.bus.Publish(event.NewEvent(event.RetryPeerRequest, map[event.Field]string{event.RemotePeer: p.id}))
 					}
 				}
 

event/common.go

@@ -8,14 +8,27 @@ const (
 	StatusRequest        = Type("StatusRequest")
 	ProtocolEngineStatus = Type("ProtocolEngineStatus")
 
+	// Attempt to outbound peer with a given remote peer
+	// attributes:
+	// RemotePeer: [eg "chpr7qm6op5vfcg2pi4vllco3h6aa7exexc4rqwnlupqhoogx2zgd6qd"
 	PeerRequest = Type("PeerRequest")
 
+	// RetryPeerRequest
+	// Identical to PeerRequest, but allows Engine to make decisions regarding blocked peers
+	// attributes:
+	// RemotePeer: [eg "chpr7qm6op5vfcg2pi4vllco3h6aa7exexc4rqwnlupqhoogx2zgd6qd"
+	RetryPeerRequest = Type("RetryPeerRequest")
+
 	// Blocking Events both Block and Unblock have the same structure
 	// attributes:
 	// RemotePeer: [eg "chpr7qm6op5vfcg2pi4vllco3h6aa7exexc4rqwnlupqhoogx2zgd6qd"
 	BlockPeer   = Type("BlockPeer")
 	UnblockPeer = Type("UnblockPeer")
 
+	// Turn on/off blocking of unknown peers (if peers aren't in the contact list then they will be autoblocked
+	BlockUnknownPeers = Type("BlockUnknownPeers")
+	AllowUnknownPeers = Type("AllowUnknownPeers")
+
 	JoinServer = Type("JoinServer")
 
 	ProtocolEngineStartListen = Type("ProtocolEngineStartListen")

protocol/connections/engine.go

@@ -10,6 +10,7 @@ import (
 	"errors"
 	"git.openprivacy.ca/openprivacy/libricochet-go/connectivity"
 	"git.openprivacy.ca/openprivacy/libricochet-go/log"
+	"git.openprivacy.ca/openprivacy/libricochet-go/utils"
 	"github.com/golang/protobuf/proto"
 	"golang.org/x/crypto/ed25519"
 	"sync"
@@ -30,6 +31,9 @@ type engine struct {
 	// Blocklist
 	blocked sync.Map
 
+	// Block Unknown Contacts
+	blockUnknownContacts bool
+
 	// Pointer to the Global Event Manager
 	eventManager event.Manager
 
@@ -51,7 +55,7 @@ type Engine interface {
 }
 
 // NewProtocolEngine initializes a new engine that runs Cwtch using the given parameters
-func NewProtocolEngine(identity primitives.Identity, privateKey ed25519.PrivateKey, acn connectivity.ACN, eventManager event.Manager, blockedPeers []string) Engine {
+func NewProtocolEngine(identity primitives.Identity, privateKey ed25519.PrivateKey, acn connectivity.ACN, eventManager event.Manager, knownPeers []string, blockedPeers []string) Engine {
 	engine := new(engine)
 	engine.identity = identity
 	engine.privateKey = privateKey
@@ -70,6 +74,7 @@ func NewProtocolEngine(identity primitives.Identity, privateKey ed25519.PrivateK
 
 	engine.eventManager.Subscribe(event.ProtocolEngineStartListen, engine.queue)
 	engine.eventManager.Subscribe(event.PeerRequest, engine.queue)
+	engine.eventManager.Subscribe(event.RetryPeerRequest, engine.queue)
 	engine.eventManager.Subscribe(event.InvitePeerToGroup, engine.queue)
 	engine.eventManager.Subscribe(event.JoinServer, engine.queue)
 	engine.eventManager.Subscribe(event.SendMessageToGroup, engine.queue)
@@ -79,6 +84,13 @@ func NewProtocolEngine(identity primitives.Identity, privateKey ed25519.PrivateK
 
 	engine.eventManager.Subscribe(event.BlockPeer, engine.queue)
 	engine.eventManager.Subscribe(event.UnblockPeer, engine.queue)
+	engine.eventManager.Subscribe(event.BlockUnknownPeers, engine.queue)
+	engine.eventManager.Subscribe(event.AllowUnknownPeers, engine.queue)
+
+	for _, peer := range knownPeers {
+		engine.blocked.Store(peer, false)
+	}
+
 	for _, peer := range blockedPeers {
 		engine.blocked.Store(peer, true)
 	}
@@ -101,13 +113,24 @@ func (e *engine) eventHandler() {
 		case event.StatusRequest:
 			e.eventManager.Publish(event.Event{EventType: event.ProtocolEngineStatus, EventID: ev.EventID})
 		case event.PeerRequest:
-			go e.peerWithOnion(ev.Data[event.RemotePeer])
+			if utils.IsValidHostname(ev.Data[event.RemotePeer]) {
+				e.blocked.Store(ev.Data[event.RemotePeer], false)
+				go e.peerWithOnion(ev.Data[event.RemotePeer])
+			}
+		case event.RetryPeerRequest:
+			// This event allows engine to treat (automated) retry peering requests differently to user-specified
+			// peer events
+			if utils.IsValidHostname(ev.Data[event.RemotePeer]) {
+				go e.peerWithOnion(ev.Data[event.RemotePeer])
+			}
 		case event.InvitePeerToGroup:
 			e.sendMessageToPeer(ev.EventID, ev.Data[event.RemotePeer], event.ContextInvite, []byte(ev.Data[event.GroupInvite]))
 		case event.JoinServer:
 			e.joinServer(ev.Data[event.GroupServer])
 		case event.DeleteContact:
 			onion := ev.Data[event.RemotePeer]
+			// We remove this peer from out blocklist which will prevent them from contacting us if we have "block unknown peers" turned on.
+			e.blocked.Delete(ev.Data[event.RemotePeer])
 			e.deleteConnection(onion)
 		case event.DeleteGroup:
 			// TODO: There isn't a way here to determine if other Groups are using a server connection...
@@ -127,7 +150,7 @@ func (e *engine) eventHandler() {
 			// We simply remove the peer from our blocklist
 			// The UI has the responsibility to reinitiate contact with the peer.
 			// (this should happen periodically in any case)
-			e.blocked.Delete(ev.Data[event.RemotePeer])
+			e.blocked.Store(ev.Data[event.RemotePeer], false)
 		case event.BlockPeer:
 			e.blocked.Store(ev.Data[event.RemotePeer], true)
 			connection, err := e.service.GetConnection(ev.Data[event.RemotePeer])
@@ -138,6 +161,10 @@ func (e *engine) eventHandler() {
 			// an ongoing Open() connection fails and so the user will see a blocked peer as still connecting (because
 			// there isn't an active connection and we are stuck waiting for tor to time out)
 			e.peerDisconnected(ev.Data[event.RemotePeer])
+		case event.AllowUnknownPeers:
+			e.blockUnknownContacts = false
+		case event.BlockUnknownPeers:
+			e.blockUnknownContacts = true
 		case event.ProtocolEngineStartListen:
 			go e.listenFn()
 		default:
@@ -149,8 +176,12 @@ func (e *engine) eventHandler() {
 func (e *engine) createPeerTemplate() *PeerApp {
 	peerAppTemplate := new(PeerApp)
 	peerAppTemplate.IsBlocked = func(onion string) bool {
-		_, blocked := e.blocked.Load(onion)
-		return blocked
+		blocked, known := e.blocked.Load(onion)
+		if !known {
+			// if we block unknown peers we will block this contact
+			return e.blockUnknownContacts
+		}
+		return blocked.(bool)
 	}
 	peerAppTemplate.MessageHandler = e.handlePeerMessage
 	peerAppTemplate.OnAcknowledgement = e.ignoreOnShutdown2(e.peerAck)
@@ -180,8 +211,8 @@ func (e *engine) Shutdown() {
 // peerWithOnion is the entry point for cwtchPeer relationships
 // needs to be run in a goroutine as will block on Open.
 func (e *engine) peerWithOnion(onion string) {
-	_, blocked := e.blocked.Load(onion)
-	if !blocked {
+	blocked, known := e.blocked.Load(onion)
+	if known && !(blocked.(bool)) {
 		e.ignoreOnShutdown(e.peerConnecting)(onion)
 		connected, err := e.service.Connect(onion, e.createPeerTemplate())
 

protocol/connections/peerserverconnection_test.go

@@ -78,7 +78,7 @@ func TestPeerServerConnection(t *testing.T) {
 	onionAddr := identity.Hostname()
 
 	manager := event.NewEventManager()
-	engine := NewProtocolEngine(identity, priv, connectivity.LocalProvider(), manager, nil)
+	engine := NewProtocolEngine(identity, priv, connectivity.LocalProvider(), manager, nil, nil)
 
 	psc := NewPeerServerConnection(engine, "127.0.0.1:5451|"+onionAddr)
 	numcalls := 0