diff --git a/connect/authenticated.go b/connect/authenticated.go
index ea628a7a6d3319f0e6f7dfe6b2bd872515f42369..518bbc2eb482f12c23005071e4e81f42c47caf38 100644
--- a/connect/authenticated.go
+++ b/connect/authenticated.go
@@ -204,8 +204,8 @@ func buildAuthenticatedConnection(conn Connection) *authenticatedHandler {
}
}
-// IsAuthenticated returns whether the AuthenticatedConnection has completed the
-// authentication process.
+// IsAuthenticated returns whether the AuthenticatedConnection has completed
+// the authentication process.
func (h *authenticatedHandler) IsAuthenticated() bool {
return h.isAuthenticated
}
diff --git a/connect/authenticated_test.go b/connect/authenticated_test.go
index 963fc8d647ba30f2747868742191f093b80cefcb..3668a742229ed15a27af3697c8a1ae05ad7deca2 100644
--- a/connect/authenticated_test.go
+++ b/connect/authenticated_test.go
@@ -20,16 +20,19 @@ import (
"time"
)
-// TestConnectWithAuthentication using the
+// TestConnectWithAuthentication will test the client/server relationship for
+// an AuthenticatedConnection. This will construct a client which will send an
+// IdentityAuthentication message to the server, who will hear it and verify
+// the contents. This will use a mock connection interface and private
+// production code helper functions for easier testing.
func TestConnectWithAuthentication(t *testing.T) {
grp := getGroup()
numPrimeByte := len(grp.GetPBytes())
- cmixHandler := newMockCmixHandler()
- mockNet, err := newMockCmix(cmixHandler, t)
- if err != nil {
- t.Fatalf("Failed to initialize mock network: %+v", err)
- }
+ // Set up cmix handler
+ mockNet := newMockCmix()
+
+ // Set up connect arguments
prng := rand.New(rand.NewSource(42))
dhPrivKey := diffieHellman.GeneratePrivateKey(
numPrimeByte, grp, prng)
@@ -42,12 +45,17 @@ func TestConnectWithAuthentication(t *testing.T) {
t.Fatalf("Faled to load private key: %v", err)
}
+ // Construct client ID the proper way as server will need to verify it
+ // using the xx.NewID function call
myId, err := xx.NewID(myRsaPrivKey.GetPublic(), salt, id.User)
if err != nil {
t.Fatalf("Failed to generate client's id: %+v", err)
}
+
+ // Generate server ID using testing interface
serverID := id.NewIdFromString("server", id.User, t)
+ // Construct recipient
recipient := contact.Contact{
ID: serverID,
DhPubKey: dhPubKey,
@@ -56,17 +64,19 @@ func TestConnectWithAuthentication(t *testing.T) {
rng := fastRNG.NewStreamGenerator(1, 1,
csprng.NewSystemRNG)
- // Create the mock connection, which will be shared by the client and server.
- // This will send the client's request to the server internally
+ // Create the mock connection, which will be shared by the client and
+ // server. This will send the client's request to the server internally
mockConn := newMockConnection(myId, serverID, dhPrivKey, dhPubKey)
- // Set up the server
+ // Set up the server's callback, which will pass the authenticated
+ // connection through via a channel
authConnChan := make(chan AuthenticatedConnection, 1)
serverCb := AuthenticatedCallback(
func(connection AuthenticatedConnection) {
authConnChan <- connection
})
+ // Initialize params with a shorter timeout to hasten test results
customParams := GetDefaultParams()
customParams.Timeout = 3 * time.Second
@@ -85,9 +95,11 @@ func TestConnectWithAuthentication(t *testing.T) {
t.Fatalf("ConnectWithAuthentication error: %+v", err)
}
+ // Wait for the server to establish it's connection via the callback
timeout := time.NewTimer(customParams.Timeout)
select {
case <-authConnChan:
+ return
case <-timeout.C:
t.Fatalf("Timed out waiting for server's authenticated connection " +
"to be established")
diff --git a/connect/utils_test.go b/connect/utils_test.go
index c81dbf90b58c549761ba868e6fc99cb284b88695..39f518b15a92bc9c588558eb4ee3fb4f52997f3f 100644
--- a/connect/utils_test.go
+++ b/connect/utils_test.go
@@ -1,13 +1,11 @@
package connect
import (
- "fmt"
"github.com/cloudflare/circl/dh/sidh"
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/gateway"
"gitlab.com/elixxir/client/cmix/identity"
- "gitlab.com/elixxir/client/cmix/identity/receptionID"
"gitlab.com/elixxir/client/cmix/message"
"gitlab.com/elixxir/client/cmix/rounds"
"gitlab.com/elixxir/client/e2e"
@@ -15,20 +13,17 @@ import (
"gitlab.com/elixxir/client/e2e/ratchet/partner/session"
"gitlab.com/elixxir/client/e2e/receive"
"gitlab.com/elixxir/client/stoppable"
- pb "gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/comms/network"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/cyclic"
cryptoE2e "gitlab.com/elixxir/crypto/e2e"
"gitlab.com/elixxir/primitives/format"
- "gitlab.com/elixxir/primitives/states"
"gitlab.com/xx_network/comms/connect"
"gitlab.com/xx_network/crypto/large"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
"gitlab.com/xx_network/primitives/netTime"
- "sync"
"time"
)
@@ -179,42 +174,13 @@ func (m mockConnection) Unregister(listenerID receive.ListenerID) {
// Mock cMix Client //
////////////////////////////////////////////////////////////////////////////////
-type mockCmixHandler struct {
- processorMap map[id.ID]map[string][]message.Processor
- sync.RWMutex
-}
-
-func newMockCmixHandler() *mockCmixHandler {
- return &mockCmixHandler{
- processorMap: make(map[id.ID]map[string][]message.Processor),
- }
-}
-
type mockCmix struct {
- numPrimeBytes int
- health bool
- handler *mockCmixHandler
- instance *network.Instance
+ instance *network.Instance
}
-func newMockCmix(handler *mockCmixHandler, face interface{}) (*mockCmix, error) {
-
- instanceComms := &connect.ProtoComms{
- Manager: connect.NewManagerTesting(face),
- }
-
- thisInstance, err := network.NewInstanceTesting(instanceComms, getNDF(),
- getNDF(), nil, nil, face)
- if err != nil {
- return nil, err
- }
+func newMockCmix() *mockCmix {
- return &mockCmix{
- numPrimeBytes: 4096,
- health: true,
- handler: handler,
- instance: thisInstance,
- }, nil
+ return &mockCmix{}
}
func (m mockCmix) Connect(ndf *ndf.NetworkDefinition) error {
@@ -226,37 +192,12 @@ func (m *mockCmix) Follow(report cmix.ClientErrorReport) (stoppable.Stoppable, e
}
func (m *mockCmix) GetMaxMessageLength() int {
- return format.NewMessage(m.numPrimeBytes).ContentsSize()
+ return 4096
}
func (m *mockCmix) Send(recipient *id.ID, fingerprint format.Fingerprint,
service message.Service, payload, mac []byte,
cmixParams cmix.CMIXParams) (id.Round, ephemeral.Id, error) {
- msg := format.NewMessage(m.numPrimeBytes)
- msg.SetContents(payload)
- msg.SetMac(mac)
- msg.SetKeyFP(fingerprint)
-
- mockRound := rounds.Round{
- State: states.COMPLETED,
- Timestamps: map[states.Round]time.Time{states.COMPLETED: netTime.Now().Add(5 * time.Second)},
- Raw: &pb.RoundInfo{},
- }
-
- m.handler.RLock()
- defer m.handler.RUnlock()
- fmt.Printf("len procs: %v\n", len(m.handler.processorMap[*recipient][service.Tag]))
- fmt.Printf("recipient: %s, tag: %s\n", recipient, service.Tag)
-
- if service.Tag == catalog.E2e {
- // todo need to activate the authenticated listener for the server here...
- return 0, ephemeral.Id{}, nil
- }
-
- for _, p := range m.handler.processorMap[*recipient][service.Tag] {
- fmt.Printf("running process with tag: %s\n", service.Tag)
- p.Process(msg, receptionID.EphemeralIdentity{}, mockRound)
- }
return 0, ephemeral.Id{}, nil
}
@@ -266,52 +207,18 @@ func (m *mockCmix) SendMany(messages []cmix.TargetedCmixMessage, p cmix.CMIXPara
}
func (m *mockCmix) AddIdentity(id *id.ID, validUntil time.Time, persistent bool) {
- m.handler.Lock()
- defer m.handler.Unlock()
-
- if _, exists := m.handler.processorMap[*id]; exists {
- return
- }
- fmt.Printf("AddIdentity recipient: %s\n", id)
-
- m.handler.processorMap[*id] = make(map[string][]message.Processor)
}
func (m *mockCmix) RemoveIdentity(id *id.ID) {
- m.handler.Lock()
- defer m.handler.Unlock()
- fmt.Printf("RemoveIdentity recipient: %s\n", id)
-
- delete(m.handler.processorMap, *id)
}
func (m *mockCmix) GetIdentity(get *id.ID) (identity.TrackedID, error) {
- m.handler.RLock()
- defer m.handler.RUnlock()
-
return identity.TrackedID{
Creation: netTime.Now().Add(-time.Minute),
}, nil
}
func (m *mockCmix) AddFingerprint(identity *id.ID, fp format.Fingerprint, mp message.Processor) error {
- if _, exists := m.handler.processorMap[*identity][fp.String()]; !exists {
-
- if underMap := m.handler.processorMap[*identity]; underMap == nil {
- underMap = make(map[string][]message.Processor)
- underMap[fp.String()] = []message.Processor{mp}
- m.handler.processorMap[*identity] = underMap
- return nil
- }
-
- m.handler.processorMap[*identity][fp.String()] =
- []message.Processor{mp}
-
- return nil
- }
-
- m.handler.processorMap[*identity][fp.String()] =
- append(m.handler.processorMap[*identity][fp.String()], mp)
return nil
}
@@ -324,25 +231,6 @@ func (m *mockCmix) DeleteClientFingerprints(identity *id.ID) {
}
func (m *mockCmix) AddService(clientID *id.ID, newService message.Service, response message.Processor) {
- fmt.Printf("AddService recipient: %s, tag: %s, proc: %v\n", clientID, newService.Tag, response)
-
- if _, exists := m.handler.processorMap[*clientID][newService.Tag]; !exists {
-
- if underMap := m.handler.processorMap[*clientID]; underMap == nil {
- underMap = make(map[string][]message.Processor)
- underMap[newService.Tag] = []message.Processor{response}
- m.handler.processorMap[*clientID] = underMap
- return
- }
-
- m.handler.processorMap[*clientID][newService.Tag] =
- []message.Processor{response}
-
- return
- }
-
- m.handler.processorMap[*clientID][newService.Tag] =
- append(m.handler.processorMap[*clientID][newService.Tag], response)
return
}
@@ -351,12 +239,6 @@ func (m *mockCmix) DeleteService(clientID *id.ID, toDelete message.Service, proc
}
func (m *mockCmix) DeleteClientService(clientID *id.ID) {
- m.handler.Lock()
- defer m.handler.Unlock()
-
- for tag := range m.handler.processorMap[*clientID] {
- delete(m.handler.processorMap[*clientID], tag)
- }
}
func (m *mockCmix) TrackServices(tracker message.ServicesTracker) {