diff --git a/api/authenticatedChannel.go b/api/auth.go
similarity index 71%
rename from api/authenticatedChannel.go
rename to api/auth.go
index 4b9ef33192279c0d5a6d36c520e17ddddf77c35d..d7a5cc362ea49dc9108e220d05c5fd45eeb5586f 100644
--- a/api/authenticatedChannel.go
+++ b/api/auth.go
@@ -9,15 +9,13 @@ package api
import (
"encoding/binary"
- "gitlab.com/elixxir/client/catalog"
"math/rand"
"github.com/cloudflare/circl/dh/sidh"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/auth"
- "gitlab.com/elixxir/client/interfaces"
- "gitlab.com/elixxir/client/storage/edge"
+ "gitlab.com/elixxir/client/e2e/ratchet/partner/session"
util "gitlab.com/elixxir/client/storage/utility"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/primitives/fact"
@@ -36,13 +34,12 @@ func (c *Client) RequestAuthenticatedChannel(recipient, me contact.Contact,
message string) (id.Round, error) {
jww.INFO.Printf("RequestAuthenticatedChannel(%s)", recipient.ID)
- if !c.network.GetHealthTracker().IsHealthy() {
+ if !c.network.IsHealthy() {
return 0, errors.New("Cannot request authenticated channel " +
"creation when the network is not healthy")
}
- return auth.RequestAuth(recipient, me, c.rng.GetStream(),
- c.storage, c.network)
+ return c.auth.Request(recipient, c.GetUser().GetContact().Facts)
}
// ResetSession resets an authenticate channel that already exists
@@ -50,18 +47,17 @@ func (c *Client) ResetSession(recipient, me contact.Contact,
message string) (id.Round, error) {
jww.INFO.Printf("ResetSession(%s)", recipient.ID)
- if !c.network.GetHealthTracker().IsHealthy() {
+ if !c.network.IsHealthy() {
return 0, errors.New("Cannot request authenticated channel " +
"creation when the network is not healthy")
}
- return auth.ResetSession(recipient, me, c.rng.GetStream(),
- c.storage, c.network)
+ return c.auth.Reset(recipient)
}
// GetAuthRegistrar gets the object which allows the registration of auth
// callbacks
-func (c *Client) GetAuthRegistrar() interfaces.Auth {
+func (c *Client) GetAuthRegistrar() auth.State {
jww.INFO.Printf("GetAuthRegistrar(...)")
return c.auth
@@ -72,7 +68,7 @@ func (c *Client) GetAuthRegistrar() interfaces.Auth {
func (c *Client) GetAuthenticatedChannelRequest(partner *id.ID) (contact.Contact, error) {
jww.INFO.Printf("GetAuthenticatedChannelRequest(%s)", partner)
- return c.storage.Auth().GetReceivedRequestData(partner)
+ return c.auth.GetReceivedRequest(partner)
}
// ConfirmAuthenticatedChannel creates an authenticated channel out of a valid
@@ -86,7 +82,7 @@ func (c *Client) GetAuthenticatedChannelRequest(partner *id.ID) (contact.Contact
func (c *Client) ConfirmAuthenticatedChannel(recipient contact.Contact) (id.Round, error) {
jww.INFO.Printf("ConfirmAuthenticatedChannel(%s)", recipient.ID)
- if !c.network.GetHealthTracker().IsHealthy() {
+ if !c.network.IsHealthy() {
return 0, errors.New("Cannot request authenticated channel " +
"creation when the network is not healthy")
}
@@ -99,18 +95,19 @@ func (c *Client) ConfirmAuthenticatedChannel(recipient contact.Contact) (id.Roun
func (c *Client) VerifyOwnership(received, verified contact.Contact) bool {
jww.INFO.Printf("VerifyOwnership(%s)", received.ID)
- return auth.VerifyOwnership(received, verified, c.storage)
+ return c.auth.VerifyOwnership(received, verified, c.e2e)
}
// HasAuthenticatedChannel returns true if an authenticated channel exists for
// the partner
func (c *Client) HasAuthenticatedChannel(partner *id.ID) bool {
- m, err := c.storage.E2e().GetPartner(partner)
+ m, err := c.e2e.GetPartner(partner)
return m != nil && err == nil
}
// Create an insecure e2e relationship with a precanned user
-func (c *Client) MakePrecannedAuthenticatedChannel(precannedID uint) (contact.Contact, error) {
+func (c *Client) MakePrecannedAuthenticatedChannel(precannedID uint) (
+ contact.Contact, error) {
precan := c.MakePrecannedContact(precannedID)
@@ -135,49 +132,15 @@ func (c *Client) MakePrecannedAuthenticatedChannel(precannedID uint) (contact.Co
mySIDHPrivKey.GeneratePublicKey(mySIDHPubKey)
// add the precanned user as a e2e contact
- sesParam := c.parameters.E2EParams
- err := c.storage.E2e().AddPartner(precan.ID, precan.DhPubKey,
- c.storage.E2e().GetDHPrivateKey(), theirSIDHPubKey,
+ // FIXME: these params need to be threaded through...
+ sesParam := session.GetDefaultParams()
+ _, err := c.e2e.AddPartner(precan.ID, precan.DhPubKey,
+ c.e2e.GetHistoricalDHPrivkey(), theirSIDHPubKey,
mySIDHPrivKey, sesParam, sesParam)
// check garbled messages in case any messages arrived before creating
// the channel
- c.network.CheckGarbledMessages()
-
- //add the e2e and rekey firngeprints
- //e2e
- sessionPartner, err := c.storage.E2e().GetPartner(precan.ID)
- if err != nil {
- jww.FATAL.Panicf("Cannot find %s right after creating: %+v", precan.ID, err)
- }
- me := c.storage.GetUser().ReceptionID
-
- c.storage.GetEdge().Add(edge.Preimage{
- Data: sessionPartner.GetE2EPreimage(),
- Type: catalog.E2e,
- Source: precan.ID[:],
- }, me)
-
- // slient (rekey)
- c.storage.GetEdge().Add(edge.Preimage{
- Data: sessionPartner.GetSilentPreimage(),
- Type: catalog.Silent,
- Source: precan.ID[:],
- }, me)
-
- // File transfer end
- c.storage.GetEdge().Add(edge.Preimage{
- Data: sessionPartner.GetFileTransferPreimage(),
- Type: catalog.EndFT,
- Source: precan.ID[:],
- }, me)
-
- // group request
- c.storage.GetEdge().Add(edge.Preimage{
- Data: sessionPartner.GetGroupRequestPreimage(),
- Type: catalog.GroupRq,
- Source: precan.ID[:],
- }, me)
+ c.network.CheckInProgressMessages()
return precan, err
}
@@ -185,14 +148,14 @@ func (c *Client) MakePrecannedAuthenticatedChannel(precannedID uint) (contact.Co
// Create an insecure e2e contact object for a precanned user
func (c *Client) MakePrecannedContact(precannedID uint) contact.Contact {
- e2eGrp := c.storage.E2e().GetGroup()
+ e2eGrp := c.storage.GetE2EGroup()
- // get the user definition
precanned := createPrecannedUser(precannedID, c.rng.GetStream(),
- c.storage.Cmix().GetGroup(), e2eGrp)
+ c.storage.GetCmixGroup(), e2eGrp)
// compute their public e2e key
- partnerPubKey := e2eGrp.ExpG(precanned.E2eDhPrivateKey, e2eGrp.NewInt(1))
+ partnerPubKey := e2eGrp.ExpG(precanned.E2eDhPrivateKey,
+ e2eGrp.NewInt(1))
return contact.Contact{
ID: precanned.ReceptionID,
@@ -206,12 +169,14 @@ func (c *Client) MakePrecannedContact(precannedID uint) contact.Contact {
// E2E relationship. An error is returned if no relationship with the partner
// is found.
func (c *Client) GetRelationshipFingerprint(partner *id.ID) (string, error) {
- m, err := c.storage.E2e().GetPartner(partner)
+ m, err := c.e2e.GetPartner(partner)
if err != nil {
- return "", errors.Errorf("could not get partner %s: %+v", partner, err)
+ return "", errors.Errorf("could not get partner %s: %+v",
+ partner, err)
} else if m == nil {
- return "", errors.Errorf("manager for partner %s is nil.", partner)
+ return "", errors.Errorf("manager for partner %s is nil.",
+ partner)
}
- return m.GetRelationshipFingerprint(), nil
+ return m.GetConnectionFingerprint(), nil
}
diff --git a/api/client.go b/api/client.go
index 85894ca42f590f64843d820d50339a6d22d3ec32..458d4ed47196febd1f846ca8eaed29611c07f17f 100644
--- a/api/client.go
+++ b/api/client.go
@@ -9,20 +9,23 @@ package api
import (
"encoding/json"
+ "math"
+ "time"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/auth"
- "gitlab.com/elixxir/client/catalog"
+ "gitlab.com/elixxir/client/backup"
"gitlab.com/elixxir/client/cmix"
- keyExchange2 "gitlab.com/elixxir/client/e2e/rekey"
+ "gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/event"
"gitlab.com/elixxir/client/interfaces"
- "gitlab.com/elixxir/client/interfaces/user"
"gitlab.com/elixxir/client/registration"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/user"
"gitlab.com/elixxir/comms/client"
- "gitlab.com/elixxir/crypto/backup"
+ cryptoBackup "gitlab.com/elixxir/crypto/backup"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/elixxir/primitives/version"
@@ -33,8 +36,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/ndf"
"gitlab.com/xx_network/primitives/region"
- "math"
- "time"
)
const followerStoppableName = "client"
@@ -44,20 +45,23 @@ type Client struct {
rng *fastRNG.StreamGenerator
// the storage session securely stores data to disk and memoizes as is
// appropriate
- storage *storage.Session
+ storage storage.Session
+
+ // user state object
+ userState *user.User
+
//object used for communications
comms *client.Comms
- // Network parameters
- parameters cmix.Params
+ // Network parameters, note e2e params wrap CMIXParams
+ parameters e2e.Params
- // note that the manager has a pointer to the context in many cases, but
- // this interface allows it to be mocked for easy testing without the
- // loop
- network interfaces.NetworkManager
+ network cmix.Client
//object used to register and communicate with permissioning
permissioning *registration.Registration
//object containing auth interactions
- auth *auth.State
+ auth auth.State
+
+ e2e e2e.Handler
//services system to track running threads
followerServices *services
@@ -68,7 +72,7 @@ type Client struct {
events *event.Manager
// Handles the triggering and delivery of backups
- backup *interfaces.BackupContainer
+ backup *backup.Backup
}
// NewClient creates client storage, generates keys, connects, and registers
@@ -78,10 +82,9 @@ type Client struct {
func NewClient(ndfJSON, storageDir string, password []byte,
registrationCode string) error {
jww.INFO.Printf("NewClient(dir: %s)", storageDir)
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
- rngStreamGen := fastRNG.NewStreamGenerator(12, 1024, csprng.NewSystemRNG)
+ rngStreamGen := fastRNG.NewStreamGenerator(12, 1024,
+ csprng.NewSystemRNG)
- // Parse the NDF
def, err := parseNDF(ndfJSON)
if err != nil {
return err
@@ -90,10 +93,12 @@ func NewClient(ndfJSON, storageDir string, password []byte,
cmixGrp, e2eGrp := decodeGroups(def)
start := time.Now()
protoUser := createNewUser(rngStreamGen, cmixGrp, e2eGrp)
- jww.DEBUG.Printf("PortableUserInfo generation took: %s", time.Now().Sub(start))
+ jww.DEBUG.Printf("PortableUserInfo generation took: %s",
+ time.Now().Sub(start))
- _, err = checkVersionAndSetupStorage(def, storageDir, password, protoUser,
- cmixGrp, e2eGrp, rngStreamGen, false, registrationCode)
+ _, err = checkVersionAndSetupStorage(def, storageDir, password,
+ protoUser, cmixGrp, e2eGrp, rngStreamGen, false,
+ registrationCode)
if err != nil {
return err
}
@@ -102,29 +107,29 @@ func NewClient(ndfJSON, storageDir string, password []byte,
return nil
}
-// NewPrecannedClient creates an insecure user with predetermined keys with nodes
-// It creates client storage, generates keys, connects, and registers
-// with the network. Note that this does not register a username/identity, but
-// merely creates a new cryptographic identity for adding such information
-// at a later date.
+// NewPrecannedClient creates an insecure user with predetermined keys
+// with nodes It creates client storage, generates keys, connects, and
+// registers with the network. Note that this does not register a
+// username/identity, but merely creates a new cryptographic identity
+// for adding such information at a later date.
func NewPrecannedClient(precannedID uint, defJSON, storageDir string,
password []byte) error {
jww.INFO.Printf("NewPrecannedClient()")
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
- rngStreamGen := fastRNG.NewStreamGenerator(12, 1024, csprng.NewSystemRNG)
+ rngStreamGen := fastRNG.NewStreamGenerator(12, 1024,
+ csprng.NewSystemRNG)
rngStream := rngStreamGen.GetStream()
- // Parse the NDF
def, err := parseNDF(defJSON)
if err != nil {
return err
}
cmixGrp, e2eGrp := decodeGroups(def)
- protoUser := createPrecannedUser(precannedID, rngStream, cmixGrp, e2eGrp)
+ protoUser := createPrecannedUser(precannedID, rngStream,
+ cmixGrp, e2eGrp)
- _, err = checkVersionAndSetupStorage(def, storageDir, password, protoUser,
- cmixGrp, e2eGrp, rngStreamGen, true, "")
+ _, err = checkVersionAndSetupStorage(def, storageDir, password,
+ protoUser, cmixGrp, e2eGrp, rngStreamGen, true, "")
if err != nil {
return err
}
@@ -132,29 +137,31 @@ func NewPrecannedClient(precannedID uint, defJSON, storageDir string,
return nil
}
-// NewVanityClient creates a user with a receptionID that starts with the supplied prefix
-// It creates client storage, generates keys, connects, and registers
-// with the network. Note that this does not register a username/identity, but
-// merely creates a new cryptographic identity for adding such information
-// at a later date.
+// NewVanityClient creates a user with a receptionID that starts with
+// the supplied prefix It creates client storage, generates keys,
+// connects, and registers with the network. Note that this does not
+// register a username/identity, but merely creates a new
+// cryptographic identity for adding such information at a later date.
func NewVanityClient(ndfJSON, storageDir string, password []byte,
registrationCode string, userIdPrefix string) error {
jww.INFO.Printf("NewVanityClient()")
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
- rngStreamGen := fastRNG.NewStreamGenerator(12, 1024, csprng.NewSystemRNG)
+
+ rngStreamGen := fastRNG.NewStreamGenerator(12, 1024,
+ csprng.NewSystemRNG)
rngStream := rngStreamGen.GetStream()
- // Parse the NDF
def, err := parseNDF(ndfJSON)
if err != nil {
return err
}
cmixGrp, e2eGrp := decodeGroups(def)
- protoUser := createNewVanityUser(rngStream, cmixGrp, e2eGrp, userIdPrefix)
+ protoUser := createNewVanityUser(rngStream, cmixGrp, e2eGrp,
+ userIdPrefix)
- _, err = checkVersionAndSetupStorage(def, storageDir, password, protoUser,
- cmixGrp, e2eGrp, rngStreamGen, false, registrationCode)
+ _, err = checkVersionAndSetupStorage(def, storageDir, password,
+ protoUser, cmixGrp, e2eGrp, rngStreamGen, false,
+ registrationCode)
if err != nil {
return err
}
@@ -163,22 +170,24 @@ func NewVanityClient(ndfJSON, storageDir string, password []byte,
return nil
}
-// NewClientFromBackup constructs a new Client from an encrypted backup. The backup
-// is decrypted using the backupPassphrase. On success a successful client creation,
-// the function will return a JSON encoded list of the E2E partners
-// contained in the backup and a json-encoded string containing parameters stored in the backup
+// NewClientFromBackup constructs a new Client from an encrypted
+// backup. The backup is decrypted using the backupPassphrase. On
+// success a successful client creation, the function will return a
+// JSON encoded list of the E2E partners contained in the backup and a
+// json-encoded string containing parameters stored in the backup
func NewClientFromBackup(ndfJSON, storageDir string, sessionPassword,
- backupPassphrase []byte, backupFileContents []byte) ([]*id.ID, string, error) {
+ backupPassphrase []byte, backupFileContents []byte) ([]*id.ID,
+ string, error) {
- backUp := &backup.Backup{}
+ backUp := &cryptoBackup.Backup{}
err := backUp.Decrypt(string(backupPassphrase), backupFileContents)
if err != nil {
- return nil, "", errors.WithMessage(err, "Failed to unmarshal decrypted client contents.")
+ return nil, "", errors.WithMessage(err,
+ "Failed to unmarshal decrypted client contents.")
}
usr := user.NewUserFromBackup(backUp)
- // Parse the NDF
def, err := parseNDF(ndfJSON)
if err != nil {
return nil, "", err
@@ -186,21 +195,23 @@ func NewClientFromBackup(ndfJSON, storageDir string, sessionPassword,
cmixGrp, e2eGrp := decodeGroups(def)
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
rngStreamGen := fastRNG.NewStreamGenerator(12, 3, csprng.NewSystemRNG)
- // Create storage object.
- // Note we do not need registration
- storageSess, err := checkVersionAndSetupStorage(def, storageDir, []byte(sessionPassword), usr,
- cmixGrp, e2eGrp, rngStreamGen, false, backUp.RegistrationCode)
+ // Note we do not need registration here
+ storageSess, err := checkVersionAndSetupStorage(def, storageDir,
+ []byte(sessionPassword), usr, cmixGrp, e2eGrp, rngStreamGen,
+ false, backUp.RegistrationCode)
- // Set registration values in storage
- storageSess.User().SetReceptionRegistrationValidationSignature(backUp.ReceptionIdentity.RegistrarSignature)
- storageSess.User().SetTransmissionRegistrationValidationSignature(backUp.TransmissionIdentity.RegistrarSignature)
- storageSess.User().SetRegistrationTimestamp(backUp.RegistrationTimestamp)
+ storageSess.SetReceptionRegistrationValidationSignature(
+ backUp.ReceptionIdentity.RegistrarSignature)
+ storageSess.SetTransmissionRegistrationValidationSignature(
+ backUp.TransmissionIdentity.RegistrarSignature)
+ storageSess.SetRegistrationTimestamp(backUp.RegistrationTimestamp)
- //move the registration state to indicate registered with registration on proto client
- err = storageSess.ForwardRegistrationStatus(storage.PermissioningComplete)
+ //move the registration state to indicate registered with
+ // registration on proto client
+ err = storageSess.ForwardRegistrationStatus(
+ storage.PermissioningComplete)
if err != nil {
return nil, "", err
}
@@ -209,37 +220,36 @@ func NewClientFromBackup(ndfJSON, storageDir string, sessionPassword,
}
// OpenClient session, but don't connect to the network or log in
-func OpenClient(storageDir string, password []byte, parameters params.Network) (*Client, error) {
+func OpenClient(storageDir string, password []byte,
+ parameters e2e.Params) (*Client, error) {
jww.INFO.Printf("OpenClient()")
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
- rngStreamGen := fastRNG.NewStreamGenerator(12, 1024, csprng.NewSystemRNG)
- // get current client version
+ rngStreamGen := fastRNG.NewStreamGenerator(12, 1024,
+ csprng.NewSystemRNG)
+
currentVersion, err := version.ParseVersion(SEMVER)
if err != nil {
- return nil, errors.WithMessage(err, "Could not parse version string.")
+ return nil, errors.WithMessage(err,
+ "Could not parse version string.")
}
- // Load Storage
passwordStr := string(password)
- storageSess, err := storage.Load(storageDir, passwordStr, currentVersion,
- rngStreamGen)
+ storageSess, err := storage.Load(storageDir, passwordStr,
+ currentVersion)
if err != nil {
return nil, err
}
- // Set up a new context
c := &Client{
storage: storageSess,
- switchboard: switchboard.New(),
rng: rngStreamGen,
comms: nil,
network: nil,
followerServices: newServices(),
parameters: parameters,
clientErrorChannel: make(chan interfaces.ClientError, 1000),
- events: event.newEventManager(),
- backup: &interfaces.BackupContainer{},
+ events: event.NewEventManager(),
+ backup: &backup.Backup{},
}
return c, nil
@@ -252,10 +262,8 @@ func NewProtoClient_Unsafe(ndfJSON, storageDir string, password,
protoClientJSON []byte) error {
jww.INFO.Printf("NewProtoClient_Unsafe")
- // Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
rngStreamGen := fastRNG.NewStreamGenerator(12, 3, csprng.NewSystemRNG)
- // Parse the NDF
def, err := parseNDF(ndfJSON)
if err != nil {
return err
@@ -263,30 +271,31 @@ func NewProtoClient_Unsafe(ndfJSON, storageDir string, password,
cmixGrp, e2eGrp := decodeGroups(def)
- // Pull the proto user from the JSON
protoUser := &user.Proto{}
err = json.Unmarshal(protoClientJSON, protoUser)
if err != nil {
return err
}
- // Initialize a user object for storage set up
usr := user.NewUserFromProto(protoUser)
- // Set up storage
- storageSess, err := checkVersionAndSetupStorage(def, storageDir, password, usr,
- cmixGrp, e2eGrp, rngStreamGen, false, protoUser.RegCode)
+ storageSess, err := checkVersionAndSetupStorage(def, storageDir,
+ password, usr, cmixGrp, e2eGrp, rngStreamGen, false,
+ protoUser.RegCode)
if err != nil {
return err
}
- // Set registration values in storage
- storageSess.User().SetReceptionRegistrationValidationSignature(protoUser.ReceptionRegValidationSig)
- storageSess.User().SetTransmissionRegistrationValidationSignature(protoUser.TransmissionRegValidationSig)
- storageSess.User().SetRegistrationTimestamp(protoUser.RegistrationTimestamp)
+ storageSess.SetReceptionRegistrationValidationSignature(
+ protoUser.ReceptionRegValidationSig)
+ storageSess.SetTransmissionRegistrationValidationSignature(
+ protoUser.TransmissionRegValidationSig)
+ storageSess.SetRegistrationTimestamp(protoUser.RegistrationTimestamp)
- //move the registration state to indicate registered with registration on proto client
- err = storageSess.ForwardRegistrationStatus(storage.PermissioningComplete)
+ // move the registration state to indicate registered with
+ // registration on proto client
+ err = storageSess.ForwardRegistrationStatus(
+ storage.PermissioningComplete)
if err != nil {
return err
}
@@ -295,26 +304,24 @@ func NewProtoClient_Unsafe(ndfJSON, storageDir string, password,
}
// Login initializes a client object from existing storage.
-func Login(storageDir string, password []byte, parameters params.Network) (*Client, error) {
+func Login(storageDir string, password []byte,
+ authCallbacks auth.Callbacks, parameters e2e.Params) (*Client, error) {
jww.INFO.Printf("Login()")
- //Open the client
c, err := OpenClient(storageDir, password, parameters)
if err != nil {
return nil, err
}
- u := c.storage.GetUser()
+ u := c.GetUser()
jww.INFO.Printf("Client Logged in: \n\tTransmisstionID: %s "+
"\n\tReceptionID: %s", u.TransmissionID, u.ReceptionID)
- // initialize comms
err = c.initComms()
if err != nil {
return nil, err
}
- //get the NDF to pass into registration and the network manager
def := c.storage.GetNDF()
//initialize registration
@@ -324,9 +331,9 @@ func Login(storageDir string, password []byte, parameters params.Network) (*Clie
return nil, err
}
} else {
- jww.WARN.Printf("Registration with permissioning skipped due to " +
- "blank permissioning address. Client will not be able to register " +
- "or track network.")
+ jww.WARN.Printf("Registration with permissioning skipped due " +
+ "to blank permissioning address. Client will not be " +
+ "able to register or track network.")
}
if def.Notification.Address != "" {
@@ -335,25 +342,38 @@ func Login(storageDir string, password []byte, parameters params.Network) (*Clie
hp.KaClientOpts.Time = time.Duration(math.MaxInt64)
hp.AuthEnabled = false
hp.MaxRetries = 5
- _, err = c.comms.AddHost(&id.NotificationBot, def.Notification.Address,
+ _, err = c.comms.AddHost(&id.NotificationBot,
+ def.Notification.Address,
[]byte(def.Notification.TlsCertificate), hp)
if err != nil {
- jww.WARN.Printf("Failed adding host for notifications: %+v", err)
+ jww.WARN.Printf("Failed adding host for "+
+ "notifications: %+v", err)
}
}
- // Initialize network and link it to context
- c.network, err = cmix.NewClient(c.storage, c.switchboard, c.rng,
- c.events, c.comms, parameters, def)
+ c.network, err = cmix.NewClient(parameters.Network, c.comms, c.storage,
+ c.storage.GetNDF(), c.rng, c.events)
+ if err != nil {
+ return nil, err
+ }
+
+ c.e2e, err = e2e.Load(c.storage.GetKV(), c.network,
+ c.GetUser().ReceptionID, c.storage.GetE2EGroup(),
+ c.rng, c.events)
if err != nil {
return nil, err
}
- // initialize the auth tracker
- c.auth = auth.NewManager(c.switchboard, c.storage, c.network, c.rng,
- c.backup.TriggerBackup, parameters.ReplayRequests)
+ // FIXME: The callbacks need to be set, so I suppose we would need to
+ // either set them via a special type or add them
+ // to the login call?
+ authParams := auth.GetDefaultParams()
+ c.auth, err = auth.NewState(c.storage.GetKV(), c.network, c.e2e, c.rng,
+ c.events, authParams, authCallbacks, c.backup.TriggerBackup)
+ if err != nil {
+ return nil, err
+ }
- // Add all processes to the followerServices
err = c.registerFollower()
if err != nil {
return nil, err
@@ -366,22 +386,20 @@ func Login(storageDir string, password []byte, parameters params.Network) (*Clie
// while replacing the base NDF. This is designed for some specific deployment
// procedures and is generally unsafe.
func LoginWithNewBaseNDF_UNSAFE(storageDir string, password []byte,
- newBaseNdf string, parameters params.Network) (*Client, error) {
+ newBaseNdf string, authCallbacks auth.Callbacks,
+ parameters e2e.Params) (*Client, error) {
jww.INFO.Printf("LoginWithNewBaseNDF_UNSAFE()")
- // Parse the NDF
def, err := parseNDF(newBaseNdf)
if err != nil {
return nil, err
}
- //Open the client
c, err := OpenClient(storageDir, password, parameters)
if err != nil {
return nil, err
}
- //initialize comms
err = c.initComms()
if err != nil {
return nil, err
@@ -390,28 +408,39 @@ func LoginWithNewBaseNDF_UNSAFE(storageDir string, password []byte,
//store the updated base NDF
c.storage.SetNDF(def)
- //initialize registration
if def.Registration.Address != "" {
err = c.initPermissioning(def)
if err != nil {
return nil, err
}
} else {
- jww.WARN.Printf("Registration with permissioning skipped due to " +
- "blank permissionign address. Client will not be able to register " +
- "or track network.")
+ jww.WARN.Printf("Registration with permissioning skipped due " +
+ "to blank permissionign address. Client will not be " +
+ "able to register or track network.")
}
- // Initialize network and link it to context
- c.network, err = cmix.NewClient(c.storage, c.switchboard, c.rng,
- c.events, c.comms, parameters, def)
+ c.network, err = cmix.NewClient(parameters.Network, c.comms, c.storage,
+ c.storage.GetNDF(), c.rng, c.events)
if err != nil {
return nil, err
}
- // initialize the auth tracker
- c.auth = auth.NewManager(c.switchboard, c.storage, c.network, c.rng,
- c.backup.TriggerBackup, parameters.ReplayRequests)
+ c.e2e, err = e2e.Load(c.storage.GetKV(), c.network,
+ c.GetUser().ReceptionID, c.storage.GetE2EGroup(),
+ c.rng, c.events)
+ if err != nil {
+ return nil, err
+ }
+
+ // FIXME: The callbacks need to be set, so I suppose we would need to
+ // either set them via a special type or add them
+ // to the login call?
+ authParams := auth.GetDefaultParams()
+ c.auth, err = auth.NewState(c.storage.GetKV(), c.network, c.e2e, c.rng,
+ c.events, authParams, authCallbacks, c.backup.TriggerBackup)
+ if err != nil {
+ return nil, err
+ }
err = c.registerFollower()
if err != nil {
@@ -421,38 +450,35 @@ func LoginWithNewBaseNDF_UNSAFE(storageDir string, password []byte,
return c, nil
}
-// LoginWithProtoClient creates a client object with a protoclient JSON containing the
-// cryptographic primitives. This is designed for some specific deployment
-//// procedures and is generally unsafe.
-func LoginWithProtoClient(storageDir string, password []byte, protoClientJSON []byte,
- newBaseNdf string, parameters params.Network) (*Client, error) {
+// LoginWithProtoClient creates a client object with a protoclient
+// JSON containing the cryptographic primitives. This is designed for
+// some specific deployment procedures and is generally unsafe.
+func LoginWithProtoClient(storageDir string, password []byte,
+ protoClientJSON []byte, newBaseNdf string, authCallbacks auth.Callbacks,
+ parameters e2e.Params) (*Client, error) {
jww.INFO.Printf("LoginWithProtoClient()")
- // Parse the NDF
def, err := parseNDF(newBaseNdf)
if err != nil {
return nil, err
}
- //Open the client
- err = NewProtoClient_Unsafe(newBaseNdf, storageDir, password, protoClientJSON)
+ err = NewProtoClient_Unsafe(newBaseNdf, storageDir, password,
+ protoClientJSON)
if err != nil {
return nil, err
}
- //Open the client
c, err := OpenClient(storageDir, password, parameters)
if err != nil {
return nil, err
}
- //initialize comms
err = c.initComms()
if err != nil {
return nil, err
}
- //store the updated base NDF
c.storage.SetNDF(def)
err = c.initPermissioning(def)
@@ -460,17 +486,28 @@ func LoginWithProtoClient(storageDir string, password []byte, protoClientJSON []
return nil, err
}
- // Initialize network and link it to context
- c.network, err = cmix.NewClient(c.storage, c.switchboard, c.rng,
- c.events, c.comms, parameters, def)
+ c.network, err = cmix.NewClient(parameters.Network, c.comms, c.storage,
+ c.storage.GetNDF(), c.rng, c.events)
if err != nil {
return nil, err
}
- // initialize the auth tracker
- c.auth = auth.NewManager(c.switchboard, c.storage, c.network, c.rng,
- c.backup.TriggerBackup, parameters.ReplayRequests)
+ c.e2e, err = e2e.Load(c.storage.GetKV(), c.network,
+ c.GetUser().ReceptionID, c.storage.GetE2EGroup(),
+ c.rng, c.events)
+ if err != nil {
+ return nil, err
+ }
+ // FIXME: The callbacks need to be set, so I suppose we would need to
+ // either set them via a special type or add them
+ // to the login call?
+ authParams := auth.GetDefaultParams()
+ c.auth, err = auth.NewState(c.storage.GetKV(), c.network, c.e2e, c.rng,
+ c.events, authParams, authCallbacks, c.backup.TriggerBackup)
+ if err != nil {
+ return nil, err
+ }
err = c.registerFollower()
if err != nil {
return nil, err
@@ -483,14 +520,16 @@ func (c *Client) initComms() error {
var err error
//get the user from session
- u := c.storage.User()
- cryptoUser := u.GetCryptographicIdentity()
+ u := c.userState
+ cryptoUser := u.CryptographicIdentity
+
+ privKey := cryptoUser.GetTransmissionRSA()
+ pubPEM := rsa.CreatePublicKeyPem(privKey.GetPublic())
+ privPEM := rsa.CreatePrivateKeyPem(privKey)
//start comms
c.comms, err = client.NewClientComms(cryptoUser.GetTransmissionID(),
- rsa.CreatePublicKeyPem(cryptoUser.GetTransmissionRSA().GetPublic()),
- rsa.CreatePrivateKeyPem(cryptoUser.GetTransmissionRSA()),
- cryptoUser.GetTransmissionSalt())
+ pubPEM, privPEM, cryptoUser.GetTransmissionSalt())
if err != nil {
return errors.WithMessage(err, "failed to load client")
}
@@ -508,18 +547,22 @@ func (c *Client) initPermissioning(def *ndf.NetworkDefinition) error {
//register with registration if necessary
if c.storage.GetRegistrationStatus() == storage.KeyGenComplete {
- jww.INFO.Printf("Client has not registered yet, attempting registration")
+ jww.INFO.Printf("Client has not registered yet, " +
+ "attempting registration")
err = c.registerWithPermissioning()
if err != nil {
- jww.ERROR.Printf("Client has failed registration: %s", err)
+ jww.ERROR.Printf("Client has failed registration: %s",
+ err)
return errors.WithMessage(err, "failed to load client")
}
- jww.INFO.Printf("Client successfully registered with the network")
+ jww.INFO.Printf("Client successfully registered " +
+ "with the network")
}
return nil
}
-// registerFollower adds the follower processes to the client's follower service list.
+// registerFollower adds the follower processes to the client's
+// follower service list.
// This should only ever be called once
func (c *Client) registerFollower() error {
//build the error callback
@@ -531,11 +574,12 @@ func (c *Client) registerFollower() error {
Trace: trace,
}:
default:
- jww.WARN.Printf("Failed to notify about ClientError from %s: %s", source, message)
+ jww.WARN.Printf("Failed to notify about ClientError "+
+ "from %s: %s", source, message)
}
}
- err := c.followerServices.add(c.events.eventService)
+ err := c.followerServices.add(c.events.EventService)
if err != nil {
return errors.WithMessage(err, "Couldn't start event reporting")
}
@@ -549,26 +593,14 @@ func (c *Client) registerFollower() error {
"the network")
}
- //register the incremental key upgrade service
- err = c.followerServices.add(c.auth.StartProcesses)
- if err != nil {
- return errors.WithMessage(err, "Failed to start following "+
- "the network")
- }
-
- //register the key exchange service
- keyXchange := func() (stoppable.Stoppable, error) {
- return keyExchange2.Start(c.switchboard, c.storage, c.network, c.parameters.Rekey)
- }
- err = c.followerServices.add(keyXchange)
-
return nil
}
// ----- Client Functions -----
// GetErrorsChannel returns a channel which passess errors from the
-// long running threads controlled by StartNetworkFollower and StopNetworkFollower
+// long running threads controlled by StartNetworkFollower and
+// StopNetworkFollower
func (c *Client) GetErrorsChannel() <-chan interfaces.ClientError {
return c.clientErrorChannel
}
@@ -584,16 +616,20 @@ func (c *Client) GetErrorsChannel() <-chan interfaces.ClientError {
// - Network Follower (/network/follow.go)
// tracks the network events and hands them off to workers for handling
// - Historical Round Retrieval (/network/rounds/historical.go)
-// Retrieves data about rounds which are too old to be stored by the client
+// Retrieves data about rounds which are too old to be
+// stored by the client
// - Message Retrieval Worker Group (/network/rounds/retrieve.go)
-// Requests all messages in a given round from the gateway of the last nodes
+// Requests all messages in a given round from the
+// gateway of the last nodes
// - Message Handling Worker Group (/network/message/handle.go)
-// Decrypts and partitions messages when signals via the Switchboard
+// Decrypts and partitions messages when signals via the
+// Switchboard
// - health Tracker (/network/health)
// Via the network instance tracks the state of the network
// - Garbled Messages (/network/message/garbled.go)
-// Can be signaled to check all recent messages which could be be decoded
-// Uses a message store on disk for persistence
+// Can be signaled to check all recent messages which
+// could be be decoded Uses a message store on disk for
+// persistence
// - Critical Messages (/network/message/critical.go)
// Ensures all protocol layer mandatory messages are sent
// Uses a message store on disk for persistence
@@ -640,20 +676,15 @@ func (c *Client) HasRunningProcessies() bool {
// Returns the health tracker for registration and polling
func (c *Client) GetHealth() interfaces.HealthTracker {
jww.INFO.Printf("GetHealth()")
- return c.network.GetHealthTracker()
-}
-
-// Returns the switchboard for Registration
-func (c *Client) GetSwitchboard() interfaces.Switchboard {
- jww.INFO.Printf("GetSwitchboard()")
- return c.switchboard
+ return c.GetHealth()
}
// RegisterRoundEventsCb registers a callback for round
// events.
func (c *Client) GetRoundEvents() interfaces.RoundEvents {
jww.INFO.Printf("GetRoundEvents()")
- jww.WARN.Printf("GetRoundEvents does not handle Client Errors edge case!")
+ jww.WARN.Printf("GetRoundEvents does not handle Client Errors " +
+ "edge case!")
return c.network.GetInstance().GetRoundEvents()
}
@@ -667,7 +698,7 @@ func (c *Client) AddService(sp Service) error {
// can be serialized into a byte stream for out-of-band sharing.
func (c *Client) GetUser() user.Info {
jww.INFO.Printf("GetUser()")
- return c.storage.GetUser()
+ return c.GetUser()
}
// GetComms returns the client comms object
@@ -681,28 +712,21 @@ func (c *Client) GetRng() *fastRNG.StreamGenerator {
}
// GetStorage returns the client storage object
-func (c *Client) GetStorage() *storage.Session {
+func (c *Client) GetStorage() storage.Session {
return c.storage
}
// GetNetworkInterface returns the client Network Interface
-func (c *Client) GetNetworkInterface() interfaces.NetworkManager {
+func (c *Client) GetNetworkInterface() cmix.Client {
return c.network
}
// GetBackup returns a pointer to the backup container so that the backup can be
// set and triggered.
-func (c *Client) GetBackup() *interfaces.BackupContainer {
+func (c *Client) GetBackup() *backup.Backup {
return c.backup
}
-// GetRateLimitParams retrieves the rate limiting parameters.
-func (c *Client) GetRateLimitParams() (uint32, uint32, int64) {
- rateLimitParams := c.storage.GetBucketParams().Get()
- return rateLimitParams.Capacity, rateLimitParams.LeakedTokens,
- rateLimitParams.LeakDuration.Nanoseconds()
-}
-
// GetNodeRegistrationStatus gets the current state of nodes registration. It
// returns the total number of nodes in the NDF and the number of those which
// are currently registers with. An error is returned if the network is not
@@ -710,27 +734,25 @@ func (c *Client) GetRateLimitParams() (uint32, uint32, int64) {
func (c *Client) GetNodeRegistrationStatus() (int, int, error) {
// Return an error if the network is not healthy
if !c.GetHealth().IsHealthy() {
- return 0, 0, errors.New("Cannot get number of nodes registrations when " +
- "network is not healthy")
+ return 0, 0, errors.New("Cannot get number of nodes " +
+ "registrations when network is not healthy")
}
- nodes := c.GetNetworkInterface().GetInstance().GetPartialNdf().Get().Nodes
-
- cmixStore := c.storage.Cmix()
+ nodes := c.network.GetInstance().GetFullNdf().Get().Nodes
var numRegistered int
var numStale = 0
for i, n := range nodes {
nid, err := id.Unmarshal(n.ID)
if err != nil {
- return 0, 0, errors.Errorf("Failed to unmarshal nodes ID %v "+
- "(#%d): %s", n.ID, i, err.Error())
+ return 0, 0, errors.Errorf("Failed to unmarshal nodes "+
+ "ID %v (#%d): %s", n.ID, i, err.Error())
}
if n.Status == ndf.Stale {
numStale += 1
continue
}
- if cmixStore.Has(nid) {
+ if c.network.HasNode(nid) {
numRegistered++
}
}
@@ -744,124 +766,50 @@ func (c *Client) GetNodeRegistrationStatus() (int, int, error) {
// partner ID an error will be returned.
func (c *Client) DeleteRequest(partnerId *id.ID) error {
jww.DEBUG.Printf("Deleting request for partner ID: %s", partnerId)
- return c.GetStorage().Auth().DeleteRequest(partnerId)
+ return c.auth.DeleteRequest(partnerId)
}
// DeleteAllRequests clears all requests from client's auth storage.
func (c *Client) DeleteAllRequests() error {
jww.DEBUG.Printf("Deleting all requests")
- return c.GetStorage().Auth().DeleteAllRequests()
+ return c.auth.DeleteAllRequests()
}
// DeleteSentRequests clears sent requests from client's auth storage.
func (c *Client) DeleteSentRequests() error {
jww.DEBUG.Printf("Deleting all sent requests")
- return c.GetStorage().Auth().DeleteSentRequests()
+ return c.auth.DeleteSentRequests()
}
// DeleteReceiveRequests clears receive requests from client's auth storage.
func (c *Client) DeleteReceiveRequests() error {
jww.DEBUG.Printf("Deleting all received requests")
- return c.GetStorage().Auth().DeleteReceiveRequests()
+ return c.auth.DeleteReceiveRequests()
}
// DeleteContact is a function which removes a partner from Client's storage
func (c *Client) DeleteContact(partnerId *id.ID) error {
jww.DEBUG.Printf("Deleting contact with ID %s", partnerId)
- // get the partner so that they can be removed from preimage store
- partner, err := c.storage.E2e().GetPartner(partnerId)
+
+ _, err := c.e2e.GetPartner(partnerId)
if err != nil {
return errors.WithMessagef(err, "Could not delete %s because "+
"they could not be found", partnerId)
}
- e2ePreimage := partner.GetE2EPreimage()
- rekeyPreimage := partner.GetSilentPreimage()
- fileTransferPreimage := partner.GetFileTransferPreimage()
- groupRequestPreimage := partner.GetGroupRequestPreimage()
- //delete the partner
- if err = c.storage.E2e().DeletePartner(partnerId); err != nil {
+ if err = c.e2e.DeletePartner(partnerId); err != nil {
return err
}
- // Trigger backup
c.backup.TriggerBackup("contact deleted")
- //delete the preimages
- if err = c.storage.GetEdge().Remove(edge.Preimage{
- Data: e2ePreimage,
- Type: catalog.E2e,
- Source: partnerId[:],
- }, c.storage.GetUser().ReceptionID); err != nil {
- jww.WARN.Printf("Failed delete the preimage for e2e "+
- "from %s on contact deletion: %+v", partnerId, err)
- }
-
- if err = c.storage.GetEdge().Remove(edge.Preimage{
- Data: rekeyPreimage,
- Type: catalog.Silent,
- Source: partnerId[:],
- }, c.storage.GetUser().ReceptionID); err != nil {
- jww.WARN.Printf("Failed delete the preimage for rekey "+
- "from %s on contact deletion: %+v", partnerId, err)
- }
-
- if err = c.storage.GetEdge().Remove(edge.Preimage{
- Data: fileTransferPreimage,
- Type: catalog.EndFT,
- Source: partnerId[:],
- }, c.storage.GetUser().ReceptionID); err != nil {
- jww.WARN.Printf("Failed delete the preimage for file transfer "+
- "from %s on contact deletion: %+v", partnerId, err)
- }
-
- if err = c.storage.GetEdge().Remove(edge.Preimage{
- Data: groupRequestPreimage,
- Type: catalog.GroupRq,
- Source: partnerId[:],
- }, c.storage.GetUser().ReceptionID); err != nil {
- jww.WARN.Printf("Failed delete the preimage for group request "+
- "from %s on contact deletion: %+v", partnerId, err)
- }
-
- //delete conversations
- c.storage.Conversations().Delete(partnerId)
+ // FIXME: Do we need this?
+ // c.e2e.Conversations().Delete(partnerId)
// call delete requests to make sure nothing is lingering.
// this is for saftey to ensure the contact can be readded
// in the future
- _ = c.storage.Auth().Delete(partnerId)
-
- return nil
-}
-
-// SetProxiedBins updates the host pool filter that filters out gateways that
-// are not in one of the specified bins.
-func (c *Client) SetProxiedBins(binStrings []string) error {
- // Convert each region string into a region.GeoBin and place in a map for
- // easy lookup
- bins := make(map[region.GeoBin]bool, len(binStrings))
- for i, binStr := range binStrings {
- bin, err := region.GetRegion(binStr)
- if err != nil {
- return errors.Errorf("failed to parse geographic bin #%d: %+v", i, err)
- }
-
- bins[bin] = true
- }
-
- // Create filter func
- f := func(m map[id.ID]int, netDef *ndf.NetworkDefinition) map[id.ID]int {
- prunedList := make(map[id.ID]int, len(m))
- for gwID, i := range m {
- if bins[netDef.Gateways[i].Bin] {
- prunedList[gwID] = i
- }
- }
- return prunedList
- }
-
- c.network.SetPoolFilter(f)
+ _ = c.auth.DeleteRequest(partnerId)
return nil
}
@@ -872,8 +820,8 @@ func (c *Client) GetPreferredBins(countryCode string) ([]string, error) {
// get the bin that the country is in
bin, exists := region.GetCountryBin(countryCode)
if !exists {
- return nil, errors.Errorf("failed to find geographic bin for country %q",
- countryCode)
+ return nil, errors.Errorf("failed to find geographic bin "+
+ "for country %q", countryCode)
}
// Add bin to list of geographic bins
@@ -884,17 +832,24 @@ func (c *Client) GetPreferredBins(countryCode string) ([]string, error) {
case region.SouthAndCentralAmerica:
bins = append(bins, region.NorthAmerica.String())
case region.MiddleEast:
- bins = append(bins, region.EasternEurope.String(), region.CentralEurope.String(), region.WesternAsia.String())
+ bins = append(bins, region.EasternEurope.String(),
+ region.CentralEurope.String(),
+ region.WesternAsia.String())
case region.NorthernAfrica:
- bins = append(bins, region.WesternEurope.String(), region.CentralEurope.String())
+ bins = append(bins, region.WesternEurope.String(),
+ region.CentralEurope.String())
case region.SouthernAfrica:
- bins = append(bins, region.WesternEurope.String(), region.CentralEurope.String())
+ bins = append(bins, region.WesternEurope.String(),
+ region.CentralEurope.String())
case region.EasternAsia:
- bins = append(bins, region.WesternAsia.String(), region.Oceania.String(), region.NorthAmerica.String())
+ bins = append(bins, region.WesternAsia.String(),
+ region.Oceania.String(), region.NorthAmerica.String())
case region.WesternAsia:
- bins = append(bins, region.EasternAsia.String(), region.Russia.String(), region.MiddleEast.String())
+ bins = append(bins, region.EasternAsia.String(),
+ region.Russia.String(), region.MiddleEast.String())
case region.Oceania:
- bins = append(bins, region.EasternAsia.String(), region.NorthAmerica.String())
+ bins = append(bins, region.EasternAsia.String(),
+ region.NorthAmerica.String())
}
return bins, nil
@@ -932,23 +887,25 @@ func decodeGroups(ndf *ndf.NetworkDefinition) (cmixGrp, e2eGrp *cyclic.Group) {
return cmixGrp, e2eGrp
}
-// checkVersionAndSetupStorage is common code shared by NewClient, NewPrecannedClient and NewVanityClient
-// it checks client version and creates a new storage for user data
+// checkVersionAndSetupStorage is common code shared by NewClient,
+// NewPrecannedClient and NewVanityClient it checks client version and
+// creates a new storage for user data
func checkVersionAndSetupStorage(def *ndf.NetworkDefinition,
storageDir string, password []byte,
protoUser user.Info,
cmixGrp, e2eGrp *cyclic.Group, rngStreamGen *fastRNG.StreamGenerator,
- isPrecanned bool, registrationCode string) (*storage.Session, error) {
+ isPrecanned bool, registrationCode string) (storage.Session, error) {
// get current client version
currentVersion, err := version.ParseVersion(SEMVER)
if err != nil {
- return nil, errors.WithMessage(err, "Could not parse version string.")
+ return nil, errors.WithMessage(err,
+ "Could not parse version string.")
}
// Create Storage
passwordStr := string(password)
storageSess, err := storage.New(storageDir, passwordStr, protoUser,
- currentVersion, cmixGrp, e2eGrp, rngStreamGen, def.RateLimits)
+ currentVersion, cmixGrp, e2eGrp)
if err != nil {
return nil, err
}
@@ -960,19 +917,15 @@ func checkVersionAndSetupStorage(def *ndf.NetworkDefinition,
//store the registration code for later use
storageSess.SetRegCode(registrationCode)
//move the registration state to keys generated
- err = storageSess.ForwardRegistrationStatus(storage.KeyGenComplete)
+ err = storageSess.ForwardRegistrationStatus(
+ storage.KeyGenComplete)
} else {
- //move the registration state to indicate registered with registration
- err = storageSess.ForwardRegistrationStatus(storage.PermissioningComplete)
+ //move the registration state to indicate registered
+ // with registration
+ err = storageSess.ForwardRegistrationStatus(
+ storage.PermissioningComplete)
}
- //add the request preiamge
- storageSess.GetEdge().Add(edge.Preimage{
- Data: preimage.GenerateRequest(protoUser.ReceptionID),
- Type: catalog.Request,
- Source: protoUser.ReceptionID[:],
- }, protoUser.ReceptionID)
-
if err != nil {
return nil, errors.WithMessage(err, "Failed to denote state "+
"change in session")
diff --git a/api/notifications.go b/api/notifications.go
index 58e97190e469a7d21d9175b9b84ddaff89b75e2c..60355a48034572902905c876591004e039b2b0b0 100644
--- a/api/notifications.go
+++ b/api/notifications.go
@@ -34,20 +34,26 @@ func (c *Client) RegisterForNotifications(token string) error {
if err != nil {
return err
}
+
+ privKey := c.userState.CryptographicIdentity.GetTransmissionRSA()
+ pubPEM := rsa.CreatePublicKeyPem(privKey.GetPublic())
+ regSig := c.userState.GetTransmissionRegistrationValidationSignature()
+ regTS := c.GetUser().RegistrationTimestamp
+
// Send the register message
_, err = c.comms.RegisterForNotifications(notificationBotHost,
&mixmessages.NotificationRegisterRequest{
Token: token,
IntermediaryId: intermediaryReceptionID,
- TransmissionRsa: rsa.CreatePublicKeyPem(c.GetStorage().User().GetCryptographicIdentity().GetTransmissionRSA().GetPublic()),
+ TransmissionRsa: pubPEM,
TransmissionSalt: c.GetUser().TransmissionSalt,
- TransmissionRsaSig: c.GetStorage().User().GetTransmissionRegistrationValidationSignature(),
+ TransmissionRsaSig: regSig,
IIDTransmissionRsaSig: sig,
- RegistrationTimestamp: c.GetUser().RegistrationTimestamp,
+ RegistrationTimestamp: regTS,
})
if err != nil {
- err := errors.Errorf(
- "RegisterForNotifications: Unable to register for notifications! %s", err)
+ err := errors.Errorf("RegisterForNotifications: Unable to "+
+ "register for notifications! %s", err)
return err
}
@@ -96,7 +102,9 @@ func (c *Client) getIidAndSig() ([]byte, []byte, error) {
stream := c.rng.GetStream()
c.GetUser()
- sig, err := rsa.Sign(stream, c.storage.User().GetCryptographicIdentity().GetTransmissionRSA(), hash.CMixHash, h.Sum(nil), nil)
+ sig, err := rsa.Sign(stream,
+ c.userState.GetTransmissionRSA(),
+ hash.CMixHash, h.Sum(nil), nil)
if err != nil {
return nil, nil, errors.WithMessage(err, "RegisterForNotifications: Failed to sign intermediary ID")
}
diff --git a/api/permissioning.go b/api/permissioning.go
index 2dd62ec87dd8a95f43bce9f93df31db105edc4ca..b4060d994c84622f3395193c145a1e257559c815 100644
--- a/api/permissioning.go
+++ b/api/permissioning.go
@@ -9,17 +9,18 @@ package api
import (
"encoding/json"
+
"github.com/pkg/errors"
- "gitlab.com/elixxir/client/interfaces/user"
"gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/user"
)
// Returns an error if registration fails.
func (c *Client) registerWithPermissioning() error {
- userData := c.storage.User()
+ userData := c.userState.CryptographicIdentity
//get the users public key
- transmissionPubKey := userData.GetCryptographicIdentity().GetTransmissionRSA().GetPublic()
- receptionPubKey := userData.GetCryptographicIdentity().GetReceptionRSA().GetPublic()
+ transmissionPubKey := userData.GetTransmissionRSA().GetPublic()
+ receptionPubKey := userData.GetReceptionRSA().GetPublic()
//load the registration code
regCode, err := c.storage.GetRegCode()
@@ -30,16 +31,19 @@ func (c *Client) registerWithPermissioning() error {
//register with registration
transmissionRegValidationSignature, receptionRegValidationSignature,
- registrationTimestamp, err := c.permissioning.Register(transmissionPubKey, receptionPubKey, regCode)
+ registrationTimestamp, err := c.permissioning.Register(
+ transmissionPubKey, receptionPubKey, regCode)
if err != nil {
return errors.WithMessage(err, "failed to register with "+
"permissioning")
}
//store the signature
- userData.SetTransmissionRegistrationValidationSignature(transmissionRegValidationSignature)
- userData.SetReceptionRegistrationValidationSignature(receptionRegValidationSignature)
- userData.SetRegistrationTimestamp(registrationTimestamp)
+ c.storage.SetTransmissionRegistrationValidationSignature(
+ transmissionRegValidationSignature)
+ c.storage.SetReceptionRegistrationValidationSignature(
+ receptionRegValidationSignature)
+ c.storage.SetRegistrationTimestamp(registrationTimestamp)
//update the registration state
err = c.storage.ForwardRegistrationStatus(storage.PermissioningComplete)
@@ -50,9 +54,9 @@ func (c *Client) registerWithPermissioning() error {
return nil
}
-// ConstructProtoUerFile is a helper function which is used for proto client testing.
-// This is used for development testing.
-func (c *Client) ConstructProtoUerFile() ([]byte, error) {
+// ConstructProtoUserFile is a helper function which is used for proto
+// client testing. This is used for development testing.
+func (c *Client) ConstructProtoUserFile() ([]byte, error) {
//load the registration code
regCode, err := c.storage.GetRegCode()
@@ -71,10 +75,10 @@ func (c *Client) ConstructProtoUerFile() ([]byte, error) {
Precanned: c.GetUser().Precanned,
RegistrationTimestamp: c.GetUser().RegistrationTimestamp,
RegCode: regCode,
- TransmissionRegValidationSig: c.storage.User().GetTransmissionRegistrationValidationSignature(),
- ReceptionRegValidationSig: c.storage.User().GetReceptionRegistrationValidationSignature(),
- E2eDhPrivateKey: c.GetStorage().E2e().GetDHPrivateKey(),
- E2eDhPublicKey: c.GetStorage().E2e().GetDHPublicKey(),
+ TransmissionRegValidationSig: c.storage.GetTransmissionRegistrationValidationSignature(),
+ ReceptionRegValidationSig: c.storage.GetReceptionRegistrationValidationSignature(),
+ E2eDhPrivateKey: c.e2e.GetHistoricalDHPrivkey(),
+ E2eDhPublicKey: c.e2e.GetHistoricalDHPubkey(),
}
jsonBytes, err := json.Marshal(Usr)
diff --git a/api/send.go b/api/send.go
index 5af5704d82b3696693997a7c6911fd08955440dc..5959d81946ada40f94d56f40b06f0ead130ae3d5 100644
--- a/api/send.go
+++ b/api/send.go
@@ -8,15 +8,18 @@
package api
import (
+ "time"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/interfaces/message"
- "gitlab.com/elixxir/client/interfaces/params"
- "gitlab.com/elixxir/crypto/e2e"
+ "gitlab.com/elixxir/client/catalog"
+ "gitlab.com/elixxir/client/cmix"
+ "gitlab.com/elixxir/client/cmix/message"
+ "gitlab.com/elixxir/client/e2e"
+ e2eCrypto "gitlab.com/elixxir/crypto/e2e"
"gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
- "time"
)
//This holds all functions to send messages over the network
@@ -24,11 +27,12 @@ import (
// SendE2E sends an end-to-end payload to the provided recipient with
// the provided msgType. Returns the list of rounds in which parts of
// the message were sent or an error if it fails.
-func (c *Client) SendE2E(m message.Send, param params.E2E) ([]id.Round,
- e2e.MessageID, time.Time, error) {
- jww.INFO.Printf("SendE2E(%s, %d. %v)", m.Recipient,
- m.MessageType, m.Payload)
- return c.network.SendE2E(m, param, nil)
+func (c *Client) SendE2E(mt catalog.MessageType, recipient *id.ID,
+ payload []byte, param e2e.Params) ([]id.Round,
+ e2eCrypto.MessageID, time.Time, error) {
+ jww.INFO.Printf("SendE2E(%s, %d. %v)", recipient,
+ mt, payload)
+ return c.e2e.SendE2E(mt, recipient, payload, param)
}
// SendUnsafe sends an unencrypted payload to the provided recipient
@@ -36,11 +40,12 @@ func (c *Client) SendE2E(m message.Send, param params.E2E) ([]id.Round,
// of the message were sent or an error if it fails.
// NOTE: Do not use this function unless you know what you are doing.
// This function always produces an error message in client logging.
-func (c *Client) SendUnsafe(m message.Send, param params.Unsafe) ([]id.Round,
+func (c *Client) SendUnsafe(mt catalog.MessageType, recipient *id.ID,
+ payload []byte, param e2e.Params) ([]id.Round, time.Time,
error) {
- jww.INFO.Printf("SendUnsafe(%s, %d. %v)", m.Recipient,
- m.MessageType, m.Payload)
- return c.network.SendUnsafe(m, param)
+ jww.INFO.Printf("SendUnsafe(%s, %d. %v)", recipient,
+ mt, payload)
+ return c.e2e.SendUnsafe(mt, recipient, payload, param)
}
// SendCMIX sends a "raw" CMIX message payload to the provided
@@ -48,24 +53,26 @@ func (c *Client) SendUnsafe(m message.Send, param params.Unsafe) ([]id.Round,
// Returns the round ID of the round the payload was sent or an error
// if it fails.
func (c *Client) SendCMIX(msg format.Message, recipientID *id.ID,
- param params.CMIX) (id.Round, ephemeral.Id, error) {
+ param cmix.CMIXParams) (id.Round, ephemeral.Id, error) {
jww.INFO.Printf("Send(%s)", string(msg.GetContents()))
- return c.network.SendCMIX(msg, recipientID, param)
+ return c.network.Send(recipientID, msg.GetKeyFP(),
+ message.GetDefaultService(recipientID),
+ msg.GetContents(), msg.GetMac(), param)
}
// SendManyCMIX sends many "raw" CMIX message payloads to each of the
// provided recipients. Used for group chat functionality. Returns the
// round ID of the round the payload was sent or an error if it fails.
-func (c *Client) SendManyCMIX(messages []message.TargetedCmixMessage,
- params params.CMIX) (id.Round, []ephemeral.Id, error) {
- return c.network.SendManyCMIX(messages, params)
+func (c *Client) SendManyCMIX(messages []cmix.TargetedCmixMessage,
+ params cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
+ return c.network.SendMany(messages, params)
}
// NewCMIXMessage Creates a new cMix message with the right properties
// for the current cMix network.
// FIXME: this is weird and shouldn't be necessary, but it is.
func (c *Client) NewCMIXMessage(contents []byte) (format.Message, error) {
- primeSize := len(c.storage.Cmix().GetGroup().GetPBytes())
+ primeSize := len(c.storage.GetCmixGroup().GetPBytes())
msg := format.NewMessage(primeSize)
if len(contents) > msg.ContentsSize() {
return format.Message{}, errors.New("Contents to long for cmix")
diff --git a/api/user.go b/api/user.go
index 5b64f0b0a2df63408cf0b6f3baa0c2a391132caf..7ed520a0ffd2d19b12c1af772713273f7fbd7210 100644
--- a/api/user.go
+++ b/api/user.go
@@ -9,19 +9,20 @@ package api
import (
"encoding/binary"
+ "math/rand"
+ "regexp"
+ "runtime"
+ "strings"
+ "sync"
+
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/interfaces/user"
+ "gitlab.com/elixxir/client/storage/user"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/crypto/signature/rsa"
"gitlab.com/xx_network/crypto/xx"
"gitlab.com/xx_network/primitives/id"
- "math/rand"
- "regexp"
- "runtime"
- "strings"
- "sync"
)
const (
@@ -30,7 +31,8 @@ const (
)
// createNewUser generates an identity for cMix
-func createNewUser(rng *fastRNG.StreamGenerator, cmix, e2e *cyclic.Group) user.Info {
+func createNewUser(rng *fastRNG.StreamGenerator, cmix,
+ e2e *cyclic.Group) user.Info {
// CMIX Keygen
var transmissionRsaKey, receptionRsaKey *rsa.PrivateKey
@@ -65,12 +67,14 @@ func createNewUser(rng *fastRNG.StreamGenerator, cmix, e2e *cyclic.Group) user.I
stream.Close()
- transmissionID, err := xx.NewID(transmissionRsaKey.GetPublic(), transmissionSalt, id.User)
+ transmissionID, err := xx.NewID(transmissionRsaKey.GetPublic(),
+ transmissionSalt, id.User)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
- receptionID, err := xx.NewID(receptionRsaKey.GetPublic(), receptionSalt, id.User)
+ receptionID, err := xx.NewID(receptionRsaKey.GetPublic(),
+ receptionSalt, id.User)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -98,13 +102,12 @@ func createDhKeys(rng *fastRNG.StreamGenerator,
go func() {
defer wg.Done()
var err error
- // DH Keygen
- // FIXME: Why 256 bits? -- this is spec but not explained, it has
- // to do with optimizing operations on one side and still preserves
- // decent security -- cite this. Why valid for BOTH e2e and cmix?
- stream := rng.GetStream()
- e2eKeyBytes, err = csprng.GenerateInGroup(e2e.GetPBytes(), 256, stream)
- stream.Close()
+ rngStream := rng.GetStream()
+ prime := e2e.GetPBytes()
+ keyLen := len(prime)
+ e2eKeyBytes, err = csprng.GenerateInGroup(prime, keyLen,
+ rngStream)
+ rngStream.Close()
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -115,7 +118,8 @@ func createDhKeys(rng *fastRNG.StreamGenerator,
defer wg.Done()
var err error
stream := rng.GetStream()
- transmissionRsaKey, err = rsa.GenerateKey(stream, rsa.DefaultRSABitLen)
+ transmissionRsaKey, err = rsa.GenerateKey(stream,
+ rsa.DefaultRSABitLen)
stream.Close()
if err != nil {
jww.FATAL.Panicf(err.Error())
@@ -126,7 +130,8 @@ func createDhKeys(rng *fastRNG.StreamGenerator,
defer wg.Done()
var err error
stream := rng.GetStream()
- receptionRsaKey, err = rsa.GenerateKey(stream, rsa.DefaultRSABitLen)
+ receptionRsaKey, err = rsa.GenerateKey(stream,
+ rsa.DefaultRSABitLen)
stream.Close()
if err != nil {
jww.FATAL.Panicf(err.Error())
@@ -140,13 +145,13 @@ func createDhKeys(rng *fastRNG.StreamGenerator,
// TODO: Add precanned user code structures here.
// creates a precanned user
-func createPrecannedUser(precannedID uint, rng csprng.Source, cmix, e2e *cyclic.Group) user.Info {
+func createPrecannedUser(precannedID uint, rng csprng.Source, cmix,
+ e2e *cyclic.Group) user.Info {
// DH Keygen
- // FIXME: Why 256 bits? -- this is spec but not explained, it has
- // to do with optimizing operations on one side and still preserves
- // decent security -- cite this. Why valid for BOTH e2e and cmix?
prng := rand.New(rand.NewSource(int64(precannedID)))
- e2eKeyBytes, err := csprng.GenerateInGroup(e2e.GetPBytes(), 256, prng)
+ prime := e2e.GetPBytes()
+ keyLen := len(prime)
+ e2eKeyBytes, err := csprng.GenerateInGroup(prime, keyLen, prng)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -178,12 +183,12 @@ func createPrecannedUser(precannedID uint, rng csprng.Source, cmix, e2e *cyclic.
// createNewVanityUser generates an identity for cMix
// The identity's ReceptionID is not random but starts with the supplied prefix
-func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix string) user.Info {
+func createNewVanityUser(rng csprng.Source, cmix,
+ e2e *cyclic.Group, prefix string) user.Info {
// DH Keygen
- // FIXME: Why 256 bits? -- this is spec but not explained, it has
- // to do with optimizing operations on one side and still preserves
- // decent security -- cite this. Why valid for BOTH e2e and cmix?
- e2eKeyBytes, err := csprng.GenerateInGroup(e2e.GetPBytes(), 256, rng)
+ prime := e2e.GetPBytes()
+ keyLen := len(prime)
+ e2eKeyBytes, err := csprng.GenerateInGroup(prime, keyLen, rng)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -203,7 +208,8 @@ func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix stri
if n != SaltSize {
jww.FATAL.Panicf("transmissionSalt size too small: %d", n)
}
- transmissionID, err := xx.NewID(transmissionRsaKey.GetPublic(), transmissionSalt, id.User)
+ transmissionID, err := xx.NewID(transmissionRsaKey.GetPublic(),
+ transmissionSalt, id.User)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -213,7 +219,9 @@ func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix stri
jww.FATAL.Panicf(err.Error())
}
- var mu sync.Mutex // just in case more than one go routine tries to access receptionSalt and receptionID
+ // just in case more than one go routine tries to access
+ // receptionSalt and receptionID
+ var mu sync.Mutex
done := make(chan struct{})
found := make(chan bool)
wg := &sync.WaitGroup{}
@@ -234,7 +242,8 @@ func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix stri
if match == false {
jww.FATAL.Panicf("Prefix contains non-Base64 characters")
}
- jww.INFO.Printf("Vanity userID generation started. Prefix: %s Ignore-Case: %v NumCPU: %d", pref, ignoreCase, cores)
+ jww.INFO.Printf("Vanity userID generation started. Prefix: %s "+
+ "Ignore-Case: %v NumCPU: %d", pref, ignoreCase, cores)
for w := 0; w < cores; w++ {
wg.Add(1)
go func() {
@@ -245,14 +254,20 @@ func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix stri
defer wg.Done()
return
default:
- n, err = csprng.NewSystemRNG().Read(rSalt)
+ n, err = csprng.NewSystemRNG().Read(
+ rSalt)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
if n != SaltSize {
- jww.FATAL.Panicf("receptionSalt size too small: %d", n)
+ jww.FATAL.Panicf(
+ "receptionSalt size "+
+ "too small: %d",
+ n)
}
- rID, err := xx.NewID(receptionRsaKey.GetPublic(), rSalt, id.User)
+ rID, err := xx.NewID(
+ receptionRsaKey.GetPublic(),
+ rSalt, id.User)
if err != nil {
jww.FATAL.Panicf(err.Error())
}
@@ -273,7 +288,8 @@ func createNewVanityUser(rng csprng.Source, cmix, e2e *cyclic.Group, prefix stri
}
}()
}
- // wait for a solution then close the done channel to signal the workers to exit
+ // wait for a solution then close the done channel to signal
+ // the workers to exit
<-found
close(done)
wg.Wait()
diff --git a/api/utilsInterfaces_test.go b/api/utilsInterfaces_test.go
index 29b5f8eb9abbc2217c1713cc25764472087701fa..617bce08b96810b920fb6ceb9aaf9ef3990f8757 100644
--- a/api/utilsInterfaces_test.go
+++ b/api/utilsInterfaces_test.go
@@ -7,21 +7,21 @@
package api
import (
+ "time"
+
+ "gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/gateway"
- "gitlab.com/elixxir/client/event"
- "gitlab.com/elixxir/client/interfaces"
- "gitlab.com/elixxir/client/interfaces/message"
- "gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/cmix/identity"
+ "gitlab.com/elixxir/client/cmix/message"
+ "gitlab.com/elixxir/client/cmix/rounds"
"gitlab.com/elixxir/client/stoppable"
pb "gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/comms/network"
- cE2e "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/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
- "time"
)
// Mock comm struct which returns no historical round data
@@ -82,46 +82,45 @@ func (ht *historicalRounds) GetHost(hostId *id.ID) (*connect.Host, bool) {
// Contains a test implementation of the networkManager interface.
type testNetworkManagerGeneric struct {
instance *network.Instance
- sender *gateway.Sender
+ sender gateway.Sender
}
type dummyEventMgr struct{}
func (d *dummyEventMgr) Report(p int, a, b, c string) {}
-func (t *testNetworkManagerGeneric) GetEventManager() event.Manager {
- return &dummyEventMgr{}
+func (d *dummyEventMgr) EventService() (stoppable.Stoppable, error) {
+ return nil, nil
}
/* Below methods built for interface adherence */
-func (t *testNetworkManagerGeneric) GetHealthTracker() interfaces.HealthTracker {
- return nil
-}
-func (t *testNetworkManagerGeneric) Follow(report interfaces.ClientErrorReport) (stoppable.Stoppable, error) {
+func (t *testNetworkManagerGeneric) Follow(report cmix.ClientErrorReport) (stoppable.Stoppable, error) {
return nil, nil
}
-func (t *testNetworkManagerGeneric) CheckGarbledMessages() {
+func (t *testNetworkManagerGeneric) GetMaxMessageLength() int { return 0 }
+
+func (t *testNetworkManagerGeneric) CheckInProgressMessages() {
return
}
func (t *testNetworkManagerGeneric) GetVerboseRounds() string {
return ""
}
-func (t *testNetworkManagerGeneric) SendE2E(message.Send, params.E2E, *stoppable.Single) (
- []id.Round, cE2e.MessageID, time.Time, error) {
- rounds := []id.Round{id.Round(0), id.Round(1), id.Round(2)}
- return rounds, cE2e.MessageID{}, time.Time{}, nil
-}
-func (t *testNetworkManagerGeneric) SendUnsafe(m message.Send, p params.Unsafe) ([]id.Round, error) {
- return nil, nil
+func (t *testNetworkManagerGeneric) AddFingerprint(identity *id.ID, fingerprint format.Fingerprint, mp message.Processor) error {
+ return nil
}
-func (t *testNetworkManagerGeneric) SendCMIX(message format.Message, rid *id.ID, p params.CMIX) (id.Round, ephemeral.Id, error) {
+
+func (t *testNetworkManagerGeneric) Send(*id.ID, format.Fingerprint,
+ message.Service, []byte, []byte, cmix.CMIXParams) (id.Round,
+ ephemeral.Id, error) {
return id.Round(0), ephemeral.Id{}, nil
}
-func (t *testNetworkManagerGeneric) SendManyCMIX(messages []message.TargetedCmixMessage, p params.CMIX) (id.Round, []ephemeral.Id, error) {
+func (t *testNetworkManagerGeneric) SendMany(messages []cmix.TargetedCmixMessage,
+ p cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
return 0, []ephemeral.Id{}, nil
}
func (t *testNetworkManagerGeneric) GetInstance() *network.Instance {
return t.instance
}
-func (t *testNetworkManagerGeneric) RegisterWithPermissioning(string) ([]byte, error) {
+func (t *testNetworkManagerGeneric) RegisterWithPermissioning(string) (
+ []byte, error) {
return nil, nil
}
func (t *testNetworkManagerGeneric) GetRemoteVersion() (string, error) {
@@ -135,7 +134,7 @@ func (t *testNetworkManagerGeneric) InProgressRegistrations() int {
return 0
}
-func (t *testNetworkManagerGeneric) GetSender() *gateway.Sender {
+func (t *testNetworkManagerGeneric) GetSender() gateway.Sender {
return t.sender
}
@@ -147,3 +146,66 @@ func (t *testNetworkManagerGeneric) RegisterAddressSizeNotification(string) (cha
func (t *testNetworkManagerGeneric) UnregisterAddressSizeNotification(string) {}
func (t *testNetworkManagerGeneric) SetPoolFilter(gateway.Filter) {}
+func (t *testNetworkManagerGeneric) AddHealthCallback(f func(bool)) uint64 {
+ return 0
+}
+func (t *testNetworkManagerGeneric) AddIdentity(id *id.ID,
+ validUntil time.Time, persistent bool) {
+}
+func (t *testNetworkManagerGeneric) RemoveIdentity(id *id.ID) {}
+func (t *testNetworkManagerGeneric) AddService(clientID *id.ID,
+ newService message.Service, response message.Processor) {
+}
+func (t *testNetworkManagerGeneric) DeleteService(clientID *id.ID,
+ toDelete message.Service, processor message.Processor) {
+}
+func (t *testNetworkManagerGeneric) DeleteClientService(clientID *id.ID) {
+}
+func (t *testNetworkManagerGeneric) DeleteFingerprint(identity *id.ID,
+ fingerprint format.Fingerprint) {
+}
+func (t *testNetworkManagerGeneric) DeleteClientFingerprints(identity *id.ID) {
+}
+func (t *testNetworkManagerGeneric) GetAddressSpace() uint8 { return 0 }
+func (t *testNetworkManagerGeneric) GetHostParams() connect.HostParams {
+ return connect.GetDefaultHostParams()
+}
+func (t *testNetworkManagerGeneric) GetIdentity(get *id.ID) (
+ identity.TrackedID, error) {
+ return identity.TrackedID{}, nil
+}
+func (t *testNetworkManagerGeneric) GetRoundResults(timeout time.Duration,
+ roundCallback cmix.RoundEventCallback, roundList ...id.Round) error {
+ return nil
+}
+func (t *testNetworkManagerGeneric) HasNode(nid *id.ID) bool { return false }
+func (t *testNetworkManagerGeneric) IsHealthy() bool { return true }
+func (t *testNetworkManagerGeneric) WasHealthy() bool { return true }
+func (t *testNetworkManagerGeneric) LookupHistoricalRound(rid id.Round,
+ callback rounds.RoundResultCallback) error {
+ return nil
+}
+func (t *testNetworkManagerGeneric) NumRegisteredNodes() int { return 0 }
+func (t *testNetworkManagerGeneric) RegisterAddressSpaceNotification(
+ tag string) (chan uint8, error) {
+ return nil, nil
+}
+func (t *testNetworkManagerGeneric) RemoveHealthCallback(uint64) {}
+func (t *testNetworkManagerGeneric) SendToAny(
+ sendFunc func(host *connect.Host) (interface{}, error),
+ stop *stoppable.Single) (interface{}, error) {
+ return nil, nil
+}
+func (t *testNetworkManagerGeneric) SendToPreferred(targets []*id.ID,
+ sendFunc gateway.SendToPreferredFunc, stop *stoppable.Single,
+ timeout time.Duration) (interface{}, error) {
+ return nil, nil
+}
+func (t *testNetworkManagerGeneric) SetGatewayFilter(f gateway.Filter) {}
+func (t *testNetworkManagerGeneric) TrackServices(
+ tracker message.ServicesTracker) {
+}
+func (t *testNetworkManagerGeneric) TriggerNodeRegistration(nid *id.ID) {}
+func (t *testNetworkManagerGeneric) UnregisterAddressSpaceNotification(
+ tag string) {
+}
diff --git a/api/utils_test.go b/api/utils_test.go
index 2171ee98fb7645daef91c2fa2cb27c378c6e98a6..4496905d51eab7344b8d2fcde840a2cd3c862d11 100644
--- a/api/utils_test.go
+++ b/api/utils_test.go
@@ -9,12 +9,13 @@ package api
import (
"bytes"
- "gitlab.com/elixxir/client/cmix/gateway"
"testing"
+ "gitlab.com/elixxir/client/cmix/gateway"
+ "gitlab.com/elixxir/client/e2e"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/interfaces/params"
pb "gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/comms/network"
"gitlab.com/elixxir/comms/testkeys"
@@ -32,7 +33,8 @@ func newTestingClient(face interface{}) (*Client, error) {
case *testing.T, *testing.M, *testing.B, *testing.PB:
break
default:
- jww.FATAL.Panicf("InitTestingSession is restricted to testing only. Got %T", face)
+ jww.FATAL.Panicf("InitTestingSession is restricted to testing "+
+ "only. Got %T", face)
}
def := getNDF(face)
@@ -41,12 +43,14 @@ func newTestingClient(face interface{}) (*Client, error) {
password := []byte("hunter2")
err := NewClient(string(marshalledDef), storageDir, password, "AAAA")
if err != nil {
- return nil, errors.Errorf("Could not construct a mock client: %v", err)
+ return nil, errors.Errorf(
+ "Could not construct a mock client: %v", err)
}
- c, err := OpenClient(storageDir, password, params.GetDefaultNetwork())
+ c, err := OpenClient(storageDir, password, e2e.GetDefaultParams())
if err != nil {
- return nil, errors.Errorf("Could not open a mock client: %v", err)
+ return nil, errors.Errorf("Could not open a mock client: %v",
+ err)
}
commsManager := connect.NewManagerTesting(face)
@@ -56,19 +60,22 @@ func newTestingClient(face interface{}) (*Client, error) {
jww.FATAL.Panicf("Failed to create new test instance: %v", err)
}
- commsManager.AddHost(&id.Permissioning, "", cert, connect.GetDefaultHostParams())
+ commsManager.AddHost(&id.Permissioning, "", cert,
+ connect.GetDefaultHostParams())
instanceComms := &connect.ProtoComms{
Manager: commsManager,
}
- thisInstance, err := network.NewInstanceTesting(instanceComms, def, def, nil, nil, face)
+ thisInstance, err := network.NewInstanceTesting(instanceComms, def,
+ def, nil, nil, face)
if err != nil {
return nil, err
}
p := gateway.DefaultPoolParams()
p.MaxPoolSize = 1
- sender, err := gateway.NewSender(p, c.rng, def, commsManager, c.storage, nil)
+ sender, err := gateway.NewSender(p, c.rng, def, commsManager,
+ c.storage, nil)
if err != nil {
return nil, err
}
diff --git a/auth/confirm.go b/auth/confirm.go
index ee89b8f1827546c740f8aa23634940e30d26deea..fc6c5b69c90fa6c5533fd26e570ad31c10e8e4a6 100644
--- a/auth/confirm.go
+++ b/auth/confirm.go
@@ -9,6 +9,7 @@ package auth
import (
"fmt"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/auth/store"
@@ -152,7 +153,7 @@ func (s *state) confirm(partner contact.Contact, serviceTag string) (
}
func sendAuthConfirm(net cmixClient, partner *id.ID,
- fp format.Fingerprint, payload, mac []byte, event event.Manager,
+ fp format.Fingerprint, payload, mac []byte, event event.Reporter,
serviceTag string) (
id.Round, error) {
svc := message.Service{
diff --git a/auth/interface.go b/auth/interface.go
index f44e221acf77e303b0e19559d5a3410335fa7a56..b8ea8865c78f89ba7ffacce3476e46aeb3ff0f7f 100644
--- a/auth/interface.go
+++ b/auth/interface.go
@@ -1,6 +1,7 @@
package auth
import (
+ "gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/primitives/fact"
"gitlab.com/xx_network/primitives/id"
@@ -60,4 +61,26 @@ type State interface {
// CallAllReceivedRequests will iterate through all pending contact requests
// and replay them on the callbacks.
CallAllReceivedRequests()
+
+ // DeleteRequest deletes sent or received requests for a
+ // specific partner ID.
+ DeleteRequest(partnerID *id.ID) error
+
+ // DeleteAllRequests clears all requests from client's auth storage.
+ DeleteAllRequests() error
+
+ // DeleteSentRequests clears all sent requests from client's auth
+ // storage.
+ DeleteSentRequests() error
+
+ // DeleteReceiveRequests clears all received requests from client's auth
+ // storage.
+ DeleteReceiveRequests() error
+
+ // GetReceivedRequest returns a contact if there's a received
+ // request for it.
+ GetReceivedRequest(partner *id.ID) (contact.Contact, error)
+
+ // VerifyOwnership checks if the received ownership proof is valid
+ VerifyOwnership(received, verified contact.Contact, e2e e2e.Handler) bool
}
diff --git a/auth/request.go b/auth/request.go
index 3e6b8c874b8243c313182d39437aca0d1d412153..a37839fd8eb065258a61867bc45a671bc3b55dc7 100644
--- a/auth/request.go
+++ b/auth/request.go
@@ -9,11 +9,15 @@ package auth
import (
"fmt"
+ "io"
+ "strings"
+
"github.com/cloudflare/circl/dh/sidh"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/message"
+ "gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/ratchet"
util "gitlab.com/elixxir/client/storage/utility"
"gitlab.com/elixxir/crypto/contact"
@@ -23,8 +27,6 @@ import (
"gitlab.com/elixxir/primitives/fact"
"gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/primitives/id"
- "io"
- "strings"
)
const terminator = ";"
@@ -199,3 +201,28 @@ func createRequestAuth(sender *id.ID, payload, ownership []byte, myDHPriv,
return &baseFmt, mac, nil
}
+
+func (s *state) GetReceivedRequest(partner *id.ID) (contact.Contact, error) {
+ return s.store.GetReceivedRequest(partner)
+}
+
+func (s *state) VerifyOwnership(received, verified contact.Contact,
+ e2e e2e.Handler) bool {
+ return VerifyOwnership(received, verified, e2e)
+}
+
+func (s *state) DeleteRequest(partnerID *id.ID) error {
+ return s.store.DeleteRequest(partnerID)
+}
+
+func (s *state) DeleteAllRequests() error {
+ return s.store.DeleteAllRequests()
+}
+
+func (s *state) DeleteSentRequests() error {
+ return s.store.DeleteSentRequests()
+}
+
+func (s *state) DeleteReceiveRequests() error {
+ return s.store.DeleteReceiveRequests()
+}
diff --git a/auth/state.go b/auth/state.go
index dfb6cb03ce7a7c8060800e7c233e5a7bcdf6a094..a3e3d59df1ff43bf8eb6ace2582a009aaedab191 100644
--- a/auth/state.go
+++ b/auth/state.go
@@ -9,6 +9,7 @@ package auth
import (
"encoding/base64"
+
"github.com/cloudflare/circl/dh/sidh"
"github.com/pkg/errors"
"gitlab.com/elixxir/client/auth/store"
@@ -38,7 +39,7 @@ type state struct {
rng *fastRNG.StreamGenerator
store *store.Store
- event event.Manager
+ event event.Reporter
params Param
@@ -100,7 +101,7 @@ type Callbacks interface {
// with a memory only versioned.KV) as well as a memory only versioned.KV for
// NewState and use GetDefaultTemporaryParams() for the parameters
func NewState(kv *versioned.KV, net cmix.Client, e2e e2e.Handler,
- rng *fastRNG.StreamGenerator, event event.Manager, params Param,
+ rng *fastRNG.StreamGenerator, event event.Reporter, params Param,
callbacks Callbacks, backupTrigger func(reason string)) (State, error) {
kv = kv.Prefix(makeStorePrefix(e2e.GetReceptionID()))
return NewStateLegacy(
@@ -113,7 +114,7 @@ func NewState(kv *versioned.KV, net cmix.Client, e2e e2e.Handler,
// Does not modify the kv prefix for backwards compatibility
// Otherwise, acts the same as NewState
func NewStateLegacy(kv *versioned.KV, net cmix.Client, e2e e2e.Handler,
- rng *fastRNG.StreamGenerator, event event.Manager, params Param,
+ rng *fastRNG.StreamGenerator, event event.Reporter, params Param,
callbacks Callbacks, backupTrigger func(reason string)) (State, error) {
s := &state{
diff --git a/cmix/client.go b/cmix/client.go
index 76fd6377fdee71f9cbe2ffc6fcdb6fdcd8197640..1dd7cff35662ce48e696bd66e06c4ce4b8db4185 100644
--- a/cmix/client.go
+++ b/cmix/client.go
@@ -11,6 +11,11 @@ package cmix
// and intra-client state are accessible through the context object.
import (
+ "math"
+ "strconv"
+ "sync/atomic"
+ "time"
+
"github.com/pkg/errors"
"gitlab.com/elixxir/client/cmix/address"
"gitlab.com/elixxir/client/cmix/gateway"
@@ -30,10 +35,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
- "math"
- "strconv"
- "sync/atomic"
- "time"
)
// fakeIdentityRange indicates the range generated between 0 (most current) and
@@ -81,7 +82,7 @@ type client struct {
verboseRounds *RoundTracker
// Event reporting API
- events event.Manager
+ events event.Reporter
// Storage of the max message length
maxMsgLen int
@@ -90,11 +91,12 @@ type client struct {
// NewClient builds a new reception client object using inputted key fields.
func NewClient(params Params, comms *commClient.Comms, session storage.Session,
ndf *ndf.NetworkDefinition, rng *fastRNG.StreamGenerator,
- events event.Manager) (Client, error) {
+ events event.Reporter) (Client, error) {
// Start network instance
instance, err := commNetwork.NewInstance(
- comms.ProtoComms, ndf, nil, nil, commNetwork.None, params.FastPolling)
+ comms.ProtoComms, ndf, nil, nil, commNetwork.None,
+ params.FastPolling)
if err != nil {
return nil, errors.WithMessage(
err, "failed to create network client")
diff --git a/cmix/message/pickup.go b/cmix/message/pickup.go
index acba1c0382c1190c8f7524dbdba40852dfa7e415..29fbb95951aea7f4cffbd1c96ba9919ab0d27ee0 100644
--- a/cmix/message/pickup.go
+++ b/cmix/message/pickup.go
@@ -8,11 +8,12 @@
package message
import (
+ "strconv"
+
"gitlab.com/elixxir/client/event"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/primitives/id"
- "strconv"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/stoppable"
@@ -47,13 +48,13 @@ type handler struct {
inProcess *MeteredCmixMessageBuffer
- events event.Manager
+ events event.Reporter
FingerprintsManager
ServicesManager
}
-func NewHandler(param Params, kv *versioned.KV, events event.Manager,
+func NewHandler(param Params, kv *versioned.KV, events event.Reporter,
standardID *id.ID) Handler {
garbled, err := NewOrLoadMeteredCmixMessageBuffer(kv, inProcessKey)
diff --git a/cmix/nodes/register.go b/cmix/nodes/register.go
index 9cd4502f04a1e9fd16269df09c07f0eb31a1d727..af18976e4402845ea513aae0e8ae400f6683bbb5 100644
--- a/cmix/nodes/register.go
+++ b/cmix/nodes/register.go
@@ -10,6 +10,10 @@ package nodes
import (
"crypto/sha256"
"encoding/hex"
+ "strconv"
+ "sync"
+ "time"
+
"github.com/golang/protobuf/proto"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
@@ -31,9 +35,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/ndf"
"gitlab.com/xx_network/primitives/netTime"
- "strconv"
- "sync"
- "time"
)
func registerNodes(r *registrar, s storage.Session, stop *stoppable.Single,
@@ -155,10 +156,9 @@ func requestKey(sender gateway.Sender, comms RegisterNodeCommsInterface,
grp := r.session.GetCmixGroup()
- // FIXME: Why 256 bits? -- this is spec but not explained, it has to do with
- // optimizing operations on one side and still preserves decent security --
- // cite this.
- dhPrivBytes, err := csprng.GenerateInGroup(grp.GetPBytes(), 256, rng)
+ prime := grp.GetPBytes()
+ keyLen := len(prime)
+ dhPrivBytes, err := csprng.GenerateInGroup(prime, keyLen, rng)
if err != nil {
return nil, nil, 0, err
}
diff --git a/cmix/params.go b/cmix/params.go
index bfd0cd1a5011fabd45c06d971da6ddd7112f7527..d823632e199e021606a3414bc2403babcc3d17b9 100644
--- a/cmix/params.go
+++ b/cmix/params.go
@@ -3,13 +3,14 @@ package cmix
import (
"encoding/base64"
"encoding/json"
+ "time"
+
"gitlab.com/elixxir/client/cmix/message"
"gitlab.com/elixxir/client/cmix/pickup"
"gitlab.com/elixxir/client/cmix/rounds"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/primitives/excludedRounds"
"gitlab.com/xx_network/primitives/id"
- "time"
)
type Params struct {
diff --git a/cmix/rounds/historical.go b/cmix/rounds/historical.go
index 98522670faf6a2635e37d300f5df25db4c451b75..6b4ffbcd727c9b2e8c70b53769fb44c46761dca7 100644
--- a/cmix/rounds/historical.go
+++ b/cmix/rounds/historical.go
@@ -40,7 +40,7 @@ type manager struct {
comms Comms
sender gateway.Sender
- events event.Manager
+ events event.Reporter
c chan roundRequest
}
@@ -63,7 +63,7 @@ type roundRequest struct {
}
func NewRetriever(param Params, comms Comms, sender gateway.Sender,
- events event.Manager) Retriever {
+ events event.Reporter) Retriever {
return &manager{
params: param,
comms: comms,
@@ -200,7 +200,7 @@ func (m *manager) processHistoricalRounds(comm Comms, stop *stoppable.Single) {
}
func processHistoricalRoundsResponse(response *pb.HistoricalRoundsResponse,
- roundRequests []roundRequest, maxRetries uint, events event.Manager) (
+ roundRequests []roundRequest, maxRetries uint, events event.Reporter) (
[]uint64, []roundRequest) {
retries := make([]roundRequest, 0)
rids := make([]uint64, 0)
diff --git a/cmix/sendCmix.go b/cmix/sendCmix.go
index 409ac2dfb34d198c8c8077baf1a27e6b91ff0354..892570a6c0770077720d9dce077a216e66db77d6 100644
--- a/cmix/sendCmix.go
+++ b/cmix/sendCmix.go
@@ -9,6 +9,9 @@ package cmix
import (
"fmt"
+ "strings"
+ "time"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/cmix/gateway"
@@ -28,8 +31,6 @@ import (
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/netTime"
"gitlab.com/xx_network/primitives/rateLimiting"
- "strings"
- "time"
)
// SendCMIX sends a "raw" cMix message payload to the provided recipient.
@@ -95,7 +96,7 @@ func (c *client) Send(recipient *id.ID, fingerprint format.Fingerprint,
// status.
func sendCmixHelper(sender gateway.Sender, msg format.Message, recipient *id.ID,
cmixParams CMIXParams, instance *network.Instance, grp *cyclic.Group,
- nodes nodes.Registrar, rng *fastRNG.StreamGenerator, events event.Manager,
+ nodes nodes.Registrar, rng *fastRNG.StreamGenerator, events event.Reporter,
senderId *id.ID, comms SendCmixCommsInterface) (id.Round, ephemeral.Id, error) {
timeStart := netTime.Now()
diff --git a/cmix/sendManyCmix.go b/cmix/sendManyCmix.go
index 6e67eff24faa65b815b618d8c6cbef0d5a110b13..69713cd5ca187e1d52d77fe2b1b739598b5d324c 100644
--- a/cmix/sendManyCmix.go
+++ b/cmix/sendManyCmix.go
@@ -9,6 +9,9 @@ package cmix
import (
"fmt"
+ "strings"
+ "time"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/cmix/gateway"
@@ -27,8 +30,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/netTime"
- "strings"
- "time"
)
// TargetedCmixMessage defines a recipient target pair in a sendMany cMix
@@ -110,7 +111,7 @@ type assembledCmixMessage struct {
func sendManyCmixHelper(sender gateway.Sender,
msgs []assembledCmixMessage, param CMIXParams, instance *network.Instance,
grp *cyclic.Group, registrar nodes.Registrar,
- rng *fastRNG.StreamGenerator, events event.Manager,
+ rng *fastRNG.StreamGenerator, events event.Reporter,
senderId *id.ID, comms SendCmixCommsInterface) (
id.Round, []ephemeral.Id, error) {
diff --git a/dummy/utils_test.go b/dummy/utils_test.go
index c6ecaf36b9906501bf1b1c8276c7dd464e2c85ef..73d3c5d0cc28b047ecea26d55e66f44c907069cb 100644
--- a/dummy/utils_test.go
+++ b/dummy/utils_test.go
@@ -8,6 +8,12 @@
package dummy
import (
+ "io"
+ "math/rand"
+ "sync"
+ "testing"
+ "time"
+
"github.com/pkg/errors"
"gitlab.com/elixxir/client/cmix/gateway"
"gitlab.com/elixxir/client/event"
@@ -25,11 +31,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
- "io"
- "math/rand"
- "sync"
- "testing"
- "time"
)
////////////////////////////////////////////////////////////////////////////////
@@ -143,7 +144,7 @@ func (tnm *testNetworkManager) SendManyCMIX([]message.TargetedCmixMessage, param
type dummyEventMgr struct{}
func (d *dummyEventMgr) Report(int, string, string, string) {}
-func (tnm *testNetworkManager) GetEventManager() event.Manager {
+func (tnm *testNetworkManager) GetEventManager() event.Reporter {
return &dummyEventMgr{}
}
diff --git a/e2e/manager.go b/e2e/manager.go
index cccf2d9694623db93a4c71e9b5491ce8db465fc3..853303bbe20633da76ff329ee6f6f4a99ec769e1 100644
--- a/e2e/manager.go
+++ b/e2e/manager.go
@@ -30,7 +30,7 @@ type manager struct {
net cmix.Client
myID *id.ID
rng *fastRNG.StreamGenerator
- events event.Manager
+ events event.Reporter
grp *cyclic.Group
crit *critical
rekeyParams rekey.Params
@@ -70,7 +70,7 @@ func initE2E(kv *versioned.KV, myID *id.ID, privKey *cyclic.Int,
// You can use a memkv for an ephemeral e2e id
func Load(kv *versioned.KV, net cmix.Client, myID *id.ID,
grp *cyclic.Group, rng *fastRNG.StreamGenerator,
- events event.Manager) (Handler, error) {
+ events event.Reporter) (Handler, error) {
kv = kv.Prefix(makeE2ePrefix(myID))
return loadE2E(kv, net, myID, grp, rng, events)
}
@@ -83,7 +83,7 @@ func Load(kv *versioned.KV, net cmix.Client, myID *id.ID,
// You can use a memkv for an ephemeral e2e id
func LoadLegacy(kv *versioned.KV, net cmix.Client, myID *id.ID,
grp *cyclic.Group, rng *fastRNG.StreamGenerator,
- events event.Manager, params rekey.Params) (Handler, error) {
+ events event.Reporter, params rekey.Params) (Handler, error) {
// Marshal the passed params data
rekeyParamsData, err := json.Marshal(params)
@@ -114,7 +114,7 @@ func LoadLegacy(kv *versioned.KV, net cmix.Client, myID *id.ID,
func loadE2E(kv *versioned.KV, net cmix.Client, myDefaultID *id.ID,
grp *cyclic.Group, rng *fastRNG.StreamGenerator,
- events event.Manager) (Handler, error) {
+ events event.Reporter) (Handler, error) {
m := &manager{
Switchboard: receive.New(),
diff --git a/e2e/params.go b/e2e/params.go
index ef54d50ee7cd1148a553055f04c53c4c2cbc9f92..52dd2d7b59f7ad6dffe999f56af84b75ed252bba 100644
--- a/e2e/params.go
+++ b/e2e/params.go
@@ -27,6 +27,9 @@ type Params struct {
// system within e2e will be used which preserves privacy
CMIX cmix.CMIXParams
+ // cMix network params
+ Network cmix.Params
+
//Authorizes the message to use a key reserved for rekeying. Do not use
//unless sending a rekey
Rekey bool
diff --git a/e2e/rekey/rekey.go b/e2e/rekey/rekey.go
index 91209bd741f62d039fc9a46276d13ab7727a2a92..8de7ef2daff692cc41914f67c3d8ea7974bb84c9 100644
--- a/e2e/rekey/rekey.go
+++ b/e2e/rekey/rekey.go
@@ -27,7 +27,7 @@ import (
)
func CheckKeyExchanges(instance *commsNetwork.Instance, grp *cyclic.Group,
- sendE2E E2eSender, events event.Manager, manager partner.Manager,
+ sendE2E E2eSender, events event.Reporter, manager partner.Manager,
param Params, sendTimeout time.Duration) {
//get all sessions that may need a key exchange
@@ -45,7 +45,7 @@ func CheckKeyExchanges(instance *commsNetwork.Instance, grp *cyclic.Group,
// session. They run the same negotiation, the former does it on a newly created
// session while the latter on an extant session
func trigger(instance *commsNetwork.Instance, grp *cyclic.Group, sendE2E E2eSender,
- events event.Manager, manager partner.Manager, inputSession *session.Session,
+ events event.Reporter, manager partner.Manager, inputSession *session.Session,
sendTimeout time.Duration, params Params) {
var negotiatingSession *session.Session
diff --git a/event/event.go b/event/event.go
index 4a15a56fb8aea3968f2d39ff1592d749f8427ee5..1b017009e991c089bd9b7be930759bd2a1d3ffec 100644
--- a/event/event.go
+++ b/event/event.go
@@ -9,10 +9,11 @@ package event
import (
"fmt"
+ "sync"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/stoppable"
- "sync"
)
// ReportableEvent is used to surface events to client users.
@@ -30,20 +31,20 @@ func (e reportableEvent) String() string {
}
// Holds state for the event reporting system
-type eventManager struct {
+type Manager struct {
eventCh chan reportableEvent
eventCbs sync.Map
}
-func newEventManager() *eventManager {
- return &eventManager{
+func NewEventManager() *Manager {
+ return &Manager{
eventCh: make(chan reportableEvent, 1000),
}
}
// Report reports an event from the client to api users, providing a
// priority, category, eventType, and details
-func (e *eventManager) Report(priority int, category, evtType, details string) {
+func (e *Manager) Report(priority int, category, evtType, details string) {
re := reportableEvent{
Priority: priority,
Category: category,
@@ -61,7 +62,7 @@ func (e *eventManager) Report(priority int, category, evtType, details string) {
// RegisterEventCallback records the given function to receive
// ReportableEvent objects. It returns the internal index
// of the callback so that it can be deleted later.
-func (e *eventManager) RegisterEventCallback(name string,
+func (e *Manager) RegisterEventCallback(name string,
myFunc Callback) error {
_, existsAlready := e.eventCbs.LoadOrStore(name, myFunc)
if existsAlready {
@@ -73,18 +74,18 @@ func (e *eventManager) RegisterEventCallback(name string,
// UnregisterEventCallback deletes the callback identified by the
// index. It returns an error if it fails.
-func (e *eventManager) UnregisterEventCallback(name string) {
+func (e *Manager) UnregisterEventCallback(name string) {
e.eventCbs.Delete(name)
}
-func (e *eventManager) eventService() (stoppable.Stoppable, error) {
+func (e *Manager) EventService() (stoppable.Stoppable, error) {
stop := stoppable.NewSingle("EventReporting")
go e.reportEventsHandler(stop)
return stop, nil
}
// reportEventsHandler reports events to every registered event callback
-func (e *eventManager) reportEventsHandler(stop *stoppable.Single) {
+func (e *Manager) reportEventsHandler(stop *stoppable.Single) {
jww.DEBUG.Print("reportEventsHandler routine started")
for {
select {
diff --git a/event/event_test.go b/event/event_test.go
index c960f1374b134f5635984a3571e154fb4e901291..d657206bac2cbf2ed761ab454e6728484931a6f6 100644
--- a/event/event_test.go
+++ b/event/event_test.go
@@ -25,8 +25,8 @@ func TestEventReporting(t *testing.T) {
evts = append(evts, evt)
}
- evtMgr := newEventManager()
- stop, _ := evtMgr.eventService()
+ evtMgr := NewEventManager()
+ stop, _ := evtMgr.EventService()
// Register a callback
err := evtMgr.RegisterEventCallback("test", myCb)
if err != nil {
diff --git a/event/interface.go b/event/interface.go
index 47e8d9795d7cc63d30b04715b92f0ec842479cf5..867e4dd9c11760474240c27a3661b910b8fe061d 100644
--- a/event/interface.go
+++ b/event/interface.go
@@ -10,7 +10,7 @@ package event
// Callback defines the callback functions for client event reports
type Callback func(priority int, category, evtType, details string)
-// Manager reporting api (used internally)
-type Manager interface {
+// Reporter reporting api (used internally)
+type Reporter interface {
Report(priority int, category, evtType, details string)
}
diff --git a/groupChat/utils_test.go b/groupChat/utils_test.go
index afbb0ec0604330cb27b35227dcacb93ff0a7f2aa..002dbb17f28fb5170d511b66126b926280beeb53 100644
--- a/groupChat/utils_test.go
+++ b/groupChat/utils_test.go
@@ -9,6 +9,11 @@ package groupChat
import (
"encoding/base64"
+ "math/rand"
+ "sync"
+ "testing"
+ "time"
+
"github.com/cloudflare/circl/dh/sidh"
"github.com/pkg/errors"
"gitlab.com/elixxir/client/catalog"
@@ -34,10 +39,6 @@ import (
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
"gitlab.com/xx_network/primitives/netTime"
- "math/rand"
- "sync"
- "testing"
- "time"
)
// newTestManager creates a new Manager for testing.
@@ -359,7 +360,7 @@ func (*testNetworkManager) DeleteService(clientID *id.ID, toDelete message.Servi
type dummyEventMgr struct{}
func (d *dummyEventMgr) Report(int, string, string, string) {}
-func (tnm *testNetworkManager) GetEventManager() event.Manager {
+func (tnm *testNetworkManager) GetEventManager() event.Reporter {
return &dummyEventMgr{}
}
diff --git a/interfaces/networkManager.go b/interfaces/networkManager.go
index b5104d1018151632d4d1ae41767378333990d1bd..1315c7d710571d694f6ca77d7b0222e2e50aa0f9 100644
--- a/interfaces/networkManager.go
+++ b/interfaces/networkManager.go
@@ -8,13 +8,14 @@
package interfaces
import (
+ "time"
+
"gitlab.com/elixxir/comms/network"
"gitlab.com/xx_network/comms/connect"
"gitlab.com/xx_network/primitives/ndf"
- "time"
- "gitlab.com/elixxir/client/interfaces/message"
- "gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/cmix"
+ "gitlab.com/elixxir/client/cmix/message"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/primitives/format"
@@ -29,24 +30,26 @@ type NetworkManager interface {
// Only one follower may run at a time.
Follow(report ClientErrorReport) (stoppable.Stoppable, error)
- /*===Sending==============================================================*/
+ /*===Sending==========================================================*/
- // SendCMIX sends a "raw" CMIX message payload to the provided recipient.
- // Returns the round ID of the round the payload was sent or an error
- // if it fails.
- SendCMIX(message format.Message, recipient *id.ID, p params.CMIX) (
+ // SendCMIX sends a "raw" CMIX message payload to the provided
+ // recipient. Returns the round ID of the round the payload
+ // was sent or an error if it fails.
+ SendCMIX(message format.Message, recipient *id.ID, p cmix.Params) (
id.Round, ephemeral.Id, error)
- // SendManyCMIX sends many "raw" cMix message payloads to each of the provided
- // recipients. Used to send messages in group chats. Metadata is NOT as well
- // protected with this call and can leak data about yourself. Should be
- // replaced with multiple uses of SendCmix in most cases. Returns the round
- // ID of the round the payload was sent or an error if it fails.
+ // SendManyCMIX sends many "raw" cMix message payloads to each
+ // of the provided recipients. Used to send messages in group
+ // chats. Metadata is NOT as well protected with this call and
+ // can leak data about yourself. Should be replaced with
+ // multiple uses of SendCmix in most cases. Returns the round
+ // ID of the round the payload was sent or an error if it
+ // fails.
// WARNING: Potentially Unsafe
- SendManyCMIX(messages []message.TargetedCmixMessage, p params.CMIX) (
+ SendManyCMIX(messages []cmix.TargetedCmixMessage, p cmix.Params) (
id.Round, []ephemeral.Id, error)
- /*===Message Reception====================================================*/
+ /*===Message Reception================================================*/
/* Identities are all network identites which the client is currently
trying to pick up message on. An identity must be added
to receive messages, fake ones will be used to poll the network
@@ -60,23 +63,24 @@ type NetworkManager interface {
// RemoveIdentity removes a currently tracked identity.
RemoveIdentity(id *id.ID)
- /* Fingerprints are the primary mechanism of identifying a picked up
- message over cMix. They are a unique one time use 255 bit vector generally
- associated with a specific encryption key, but can be used for an
- alternative protocol.When registering a fingerprint, a MessageProcessor
- is registered to handle the message.*/
+ /* Fingerprints are the primary mechanism of identifying a
+ picked up message over cMix. They are a unique one time use
+ 255 bit vector generally associated with a specific encryption
+ key, but can be used for an alternative protocol.When
+ registering a fingerprint, a MessageProcessor is registered to
+ handle the message.*/
// AddFingerprint - Adds a fingerprint which will be handled by a
// specific processor for messages received by the given identity
AddFingerprint(identity *id.ID, fingerprint format.Fingerprint,
- mp MessageProcessor) error
+ mp message.Processor) error
- // DeleteFingerprint deletes a single fingerprint associated with the given
- // identity if it exists
+ // DeleteFingerprint deletes a single fingerprint associated
+ // with the given identity if it exists
DeleteFingerprint(identity *id.ID, fingerprint format.Fingerprint)
- // DeleteClientFingerprints deletes al fingerprint associated with the given
- // identity if it exists
+ // DeleteClientFingerprints deletes al fingerprint associated
+ // with the given identity if it exists
DeleteClientFingerprints(identity *id.ID)
/* trigger - predefined hash based tags appended to all cMix messages
@@ -87,60 +91,72 @@ type NetworkManager interface {
notifications system, or can be used to implement custom non fingerprint
processing of payloads. I.E. key negotiation, broadcast negotiation
- A tag is appended to the message of the format tag = H(H(messageContents),
- preimage) and trial hashing is used to determine if a message adheres to a
- tag.
- WARNING: If a preimage is known by an adversary, they can determine which
- messages are for the client on reception (which is normally hidden due to
- collision between ephemeral IDs.
+ A tag is appended to the message of the format tag =
+ H(H(messageContents), preimage) and trial hashing is used to
+ determine if a message adheres to a tag.
- Due to the extra overhead of trial hashing, triggers are processed after fingerprints.
- If a fingerprint match occurs on the message, triggers will not be handled.
+ WARNING: If a preimage is known by an adversary, they can
+ determine which messages are for the client on reception
+ (which is normally hidden due to collision between ephemeral
+ IDs.
- Triggers are address to the session. When starting a new client, all triggers must be
- re-added before StartNetworkFollower is called.
+ Due to the extra overhead of trial hashing, triggers are
+ processed after fingerprints. If a fingerprint match occurs
+ on the message, triggers will not be handled.
+
+ Triggers are address to the session. When starting a new
+ client, all triggers must be re-added before
+ StartNetworkFollower is called.
*/
- // AddTrigger - Adds a trigger which can call a message handing function or
- // be used for notifications. Multiple triggers can be registered for the
- // same preimage.
+ // AddTrigger - Adds a trigger which can call a message
+ // handing function or be used for notifications. Multiple
+ // triggers can be registered for the same preimage.
// preimage - the preimage which is triggered on
- // type - a descriptive string of the trigger. Generally used in notifications
- // source - a byte buffer of related data. Generally used in notifications.
+ // type - a descriptive string of the trigger. Generally
+ // used in notifications
+ // source - a byte buffer of related data. Generally used in
+ // notifications.
// Example: Sender ID
- AddTrigger(identity *id.ID, newTrigger Trigger, response MessageProcessor)
+ AddTrigger(identity *id.ID, newTrigger message.Service,
+ response message.Processor)
// DeleteTrigger - If only a single response is associated with the
// preimage, the entire preimage is removed. If there is more than one
// response, only the given response is removed if nil is passed in for
// response, all triggers for the preimage will be removed
- DeleteTrigger(identity *id.ID, preimage Preimage, response MessageProcessor) error
+ DeleteTrigger(identity *id.ID, preimage Preimage,
+ response message.Processor) error
- // DeleteClientTriggers - deletes all triggers assoseated with the given identity
+ // DeleteClientTriggers - deletes all triggers assoseated with
+ // the given identity
DeleteClientTriggers(identity *id.ID)
- // TrackTriggers - Registers a callback which will get called every time triggers change.
+ // TrackTriggers - Registers a callback which will get called
+ // every time triggers change.
// It will receive the triggers list every time it is modified.
// Will only get callbacks while the Network Follower is running.
// Multiple trackTriggers can be registered
- TrackTriggers(TriggerTracker)
+ TrackServices(message.ServicesTracker)
/* In inProcess */
- // it is possible to receive a message over cMix before the fingerprints or
- // triggers are registered. As a result, when handling fails, messages are
- // put in the inProcess que for a set number of retries.
+ // it is possible to receive a message over cMix before the
+ // fingerprints or triggers are registered. As a result, when
+ // handling fails, messages are put in the inProcess que for a
+ // set number of retries.
// CheckInProgressMessages - retry processing all messages in check in
// progress messages. Call this after adding fingerprints or triggers
//while the follower is running.
CheckInProgressMessages()
- /*===Nodes================================================================*/
- /* Keys must be registed with nodes in order to send messages throug them.
- this process is in general automatically handled by the Network Manager*/
+ /*===Nodes============================================================*/
+ /* Keys must be registed with nodes in order to send messages
+ throug them. this process is in general automatically handled
+ by the Network Manager*/
- // HasNode can be used to determine if a keying relationship exists with a
- // node.
+ // HasNode can be used to determine if a keying relationship
+ // exists with a node.
HasNode(nid *id.ID) bool
// NumRegisteredNodes Returns the total number of nodes we have a keying
@@ -150,7 +166,7 @@ type NetworkManager interface {
// Triggers the generation of a keying relationship with a given node
TriggerNodeRegistration(nid *id.ID)
- /*===Historical Rounds====================================================*/
+ /*===Historical Rounds================================================*/
/* A complete set of round info is not kept on the client, and sometimes
the network will need to be queried to get round info. Historical rounds
is the system internal to the Network Manager to do this.
@@ -158,52 +174,59 @@ type NetworkManager interface {
// LookupHistoricalRound - looks up the passed historical round on the
// network
- LookupHistoricalRound(rid id.Round, callback func(info *mixmessages.RoundInfo,
- success bool)) error
+ LookupHistoricalRound(rid id.Round,
+ callback func(info *mixmessages.RoundInfo,
+ success bool)) error
- /*===Sender===============================================================*/
- /* The sender handles sending comms to the network. It tracks connections to
- gateways and handles proxying to gateways for targeted comms. It can be
- used externally to contact gateway directly, bypassing the majority of
- the network package*/
+ /*===Sender===========================================================*/
+ /* The sender handles sending comms to the network. It tracks
+ connections to gateways and handles proxying to gateways for
+ targeted comms. It can be used externally to contact gateway
+ directly, bypassing the majority of the network package*/
// SendToAny can be used to send the comm to any gateway in the network.
- SendToAny(sendFunc func(host *connect.Host) (interface{}, error), stop *stoppable.Single) (interface{}, error)
+ SendToAny(sendFunc func(host *connect.Host) (interface{}, error),
+ stop *stoppable.Single) (interface{}, error)
// SendToPreferred sends to a specific gateway, doing so through another
// gateway as a proxy if not directly connected.
SendToPreferred(targets []*id.ID, sendFunc func(host *connect.Host,
target *id.ID, timeout time.Duration) (interface{}, error),
- stop *stoppable.Single, timeout time.Duration) (interface{}, error)
+ stop *stoppable.Single, timeout time.Duration) (interface{},
+ error)
- // SetGatewayFilter sets a function which will be used to filter gateways
- // before connecting.
+ // SetGatewayFilter sets a function which will be used to
+ // filter gateways before connecting.
SetGatewayFilter(f func(map[id.ID]int,
*ndf.NetworkDefinition) map[id.ID]int)
- // GetHostParams - returns the host params used when connectign to gateways
+ // GetHostParams - returns the host params used when
+ // connectign to gateways
GetHostParams() connect.HostParams
- /*===Address Space========================================================*/
- // The network compasses identities into a smaller address space to cause
- // collisions and hide the actual recipient of messages. These functions
- // allow for the tracking of this addresses space. In general, address space
- // issues are completely handled by the network package
+ /*===Address Space====================================================*/
+ // The network compasses identities into a smaller address
+ // space to cause collisions and hide the actual recipient of
+ // messages. These functions allow for the tracking of this
+ // addresses space. In general, address space issues are
+ // completely handled by the network package
- // GetAddressSpace GetAddressSize returns the current address size of IDs. Blocks until an
- // address size is known.
+ // GetAddressSpace GetAddressSize returns the current address
+ // size of IDs. Blocks until an address size is known.
GetAddressSpace() uint8
- // RegisterAddressSpaceNotification returns a channel that will trigger for
- // every address space size update. The provided tag is the unique ID for
- // the channel. Returns an error if the tag is already used.
+ // RegisterAddressSpaceNotification returns a channel that
+ // will trigger for every address space size update. The
+ // provided tag is the unique ID for the channel. Returns an
+ // error if the tag is already used.
RegisterAddressSpaceNotification(tag string) (chan uint8, error)
- // UnregisterAddressSpaceNotification stops broadcasting address space size
- // updates on the channel with the specified tag.
+ // UnregisterAddressSpaceNotification stops broadcasting
+ // address space size updates on the channel with the
+ // specified tag.
UnregisterAddressSpaceNotification(tag string)
- /*===Accessors============================================================*/
+ /*===Accessors========================================================*/
// GetInstance returns the network instance object, which tracks the
// state of the network
@@ -218,8 +241,3 @@ type NetworkManager interface {
}
type Preimage [32]byte
-
-type ClientErrorReport func(source, message, trace string)
-
-//for use in key exchange which needs to be callable inside of network
-///type SendE2E func(m message.Send, p params.E2E, stop *stoppable.Single) ([]id.Round, e2e.MessageID, time.Time, error)
diff --git a/interfaces/switchboard.go b/interfaces/switchboard.go
deleted file mode 100644
index 2566bfb51de98fe6f5ce6abf0b1038b752f78a74..0000000000000000000000000000000000000000
--- a/interfaces/switchboard.go
+++ /dev/null
@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-///////////////////////////////////////////////////////////////////////////////
-
-package interfaces
-
-import (
- "gitlab.com/elixxir/client/interfaces/message"
- "gitlab.com/elixxir/client/switchboard"
- "gitlab.com/xx_network/primitives/id"
-)
-
-// public switchboard interface which only allows registration and does not
-// allow speaking messages
-type Switchboard interface {
- // Registers a new listener. Returns the ID of the new listener.
- // Keep this around if you want to be able to delete the listener later.
- //
- // name is used for debug printing and not checked for uniqueness
- //
- // user: 0 for all, or any user ID to listen for messages from a particular
- // user. 0 can be id.ZeroUser or id.ZeroID
- // messageType: 0 for all, or any message type to listen for messages of
- // that type. 0 can be Receive.AnyType
- // newListener: something implementing the Listener interface. Do not
- // pass nil to this.
- //
- // If a message matches multiple listeners, all of them will hear the
- // message.
- RegisterListener(user *id.ID, messageType message.Type,
- newListener switchboard.Listener) switchboard.ListenerID
-
- // Registers a new listener built around the passed function.
- // Returns the ID of the new listener.
- // Keep this around if you want to be able to delete the listener later.
- //
- // name is used for debug printing and not checked for uniqueness
- //
- // user: 0 for all, or any user ID to listen for messages from a particular
- // user. 0 can be id.ZeroUser or id.ZeroID
- // messageType: 0 for all, or any message type to listen for messages of
- // that type. 0 can be Receive.AnyType
- // newListener: a function implementing the ListenerFunc function type.
- // Do not pass nil to this.
- //
- // If a message matches multiple listeners, all of them will hear the
- // message.
- RegisterFunc(name string, user *id.ID, messageType message.Type,
- newListener switchboard.ListenerFunc) switchboard.ListenerID
-
- // Registers a new listener built around the passed channel.
- // Returns the ID of the new listener.
- // Keep this around if you want to be able to delete the listener later.
- //
- // name is used for debug printing and not checked for uniqueness
- //
- // user: 0 for all, or any user ID to listen for messages from a particular
- // user. 0 can be id.ZeroUser or id.ZeroID
- // messageType: 0 for all, or any message type to listen for messages of
- // that type. 0 can be Receive.AnyType
- // newListener: an item channel.
- // Do not pass nil to this.
- //
- // If a message matches multiple listeners, all of them will hear the
- // message.
- RegisterChannel(name string, user *id.ID, messageType message.Type,
- newListener chan message.Receive) switchboard.ListenerID
-
- // Unregister removes the listener with the specified ID so it will no
- // longer get called
- Unregister(listenerID switchboard.ListenerID)
-}
diff --git a/interfaces/user/proto.go b/interfaces/user/proto.go
deleted file mode 100644
index 657c2e714d70f06b88c6d0866ec2bbca5015f24e..0000000000000000000000000000000000000000
--- a/interfaces/user/proto.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package user
-
-import (
- "gitlab.com/elixxir/crypto/cyclic"
- "gitlab.com/xx_network/crypto/signature/rsa"
- "gitlab.com/xx_network/primitives/id"
-)
-
-type Proto struct {
- //General Identity
- TransmissionID *id.ID
- TransmissionSalt []byte
- TransmissionRSA *rsa.PrivateKey
- ReceptionID *id.ID
- ReceptionSalt []byte
- ReceptionRSA *rsa.PrivateKey
- Precanned bool
- // Timestamp in which user has registered with the network
- RegistrationTimestamp int64
-
- RegCode string
-
- TransmissionRegValidationSig []byte
- ReceptionRegValidationSig []byte
-
- //e2e Identity
- E2eDhPrivateKey *cyclic.Int
- E2eDhPublicKey *cyclic.Int
-}
diff --git a/storage/ndf_test.go b/storage/ndf_test.go
index ece36461e5368cd110b0004d95fc09bf3f28837f..4d48ab2d28d7330511f8474a9a335ef023505eb6 100644
--- a/storage/ndf_test.go
+++ b/storage/ndf_test.go
@@ -17,10 +17,10 @@ func TestSession_SetGetNDF(t *testing.T) {
testNdf := getNDF()
sess.SetNDF(testNdf)
- if !reflect.DeepEqual(testNdf, sess.ndf) {
+ if !reflect.DeepEqual(testNdf, sess.GetNDF()) {
t.Errorf("SetNDF error: "+
"Unexpected value after setting ndf:"+
- "Expected: %v\n\tReceived: %v", testNdf, sess.ndf)
+ "Expected: %v\n\tReceived: %v", testNdf, sess.GetNDF())
}
receivedNdf := sess.GetNDF()
diff --git a/storage/session.go b/storage/session.go
index 2f2c543e8f3096c3875b4f553fc8df964213a003..e9bee8ae363597a4e43e6b4b4fb2a30cfc938ecf 100644
--- a/storage/session.go
+++ b/storage/session.go
@@ -10,15 +10,15 @@
package storage
import (
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/xx_network/crypto/large"
"sync"
"testing"
"time"
+ "gitlab.com/elixxir/client/storage/utility"
+ "gitlab.com/xx_network/crypto/large"
+
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- userInterface "gitlab.com/elixxir/client/interfaces/user"
"gitlab.com/elixxir/client/storage/clientVersion"
"gitlab.com/elixxir/client/storage/user"
"gitlab.com/elixxir/client/storage/versioned"
@@ -60,7 +60,7 @@ type Session interface {
IsPrecanned() bool
SetUsername(username string) error
GetUsername() (string, error)
- PortableUserInfo() userInterface.Info
+ PortableUserInfo() user.Info
GetTransmissionRegistrationValidationSignature() []byte
GetReceptionRegistrationValidationSignature() []byte
GetRegistrationTimestamp() time.Time
@@ -103,7 +103,7 @@ func initStore(baseDir, password string) (*session, error) {
}
// Creates new UserData in the session
-func New(baseDir, password string, u userInterface.Info,
+func New(baseDir, password string, u user.Info,
currentVersion version.Version, cmixGrp, e2eGrp *cyclic.Group) (Session, error) {
s, err := initStore(baseDir, password)
diff --git a/storage/user/Info.go b/storage/user/Info.go
deleted file mode 100644
index 8091bffe0c38791c93a944621639a1679b3d8895..0000000000000000000000000000000000000000
--- a/storage/user/Info.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package user
-
-import "gitlab.com/elixxir/client/interfaces/user"
-
-func (u *User) PortableUserInfo() user.Info {
- ci := u.CryptographicIdentity
- return user.Info{
- TransmissionID: ci.GetTransmissionID().DeepCopy(),
- TransmissionSalt: copySlice(ci.GetTransmissionSalt()),
- TransmissionRSA: ci.GetTransmissionRSA(),
- ReceptionID: ci.GetReceptionID().DeepCopy(),
- RegistrationTimestamp: u.GetRegistrationTimestamp().UnixNano(),
- ReceptionSalt: copySlice(ci.GetReceptionSalt()),
- ReceptionRSA: ci.GetReceptionRSA(),
- Precanned: ci.IsPrecanned(),
- //fixme: set these in the e2e layer, the command line layer
- //needs more logical seperation so this can be removed
- E2eDhPrivateKey: nil,
- E2eDhPublicKey: nil,
- }
-
-}
-
-func copySlice(s []byte) []byte {
- n := make([]byte, len(s))
- copy(n, s)
- return n
-}
diff --git a/interfaces/user/user.go b/storage/user/info.go
similarity index 66%
rename from interfaces/user/user.go
rename to storage/user/info.go
index 0e3c6ca0331756882b38ce9706c1ffdbbcf65e96..11d9381ef07cbad22a91dc49db8cff48d551fed8 100644
--- a/interfaces/user/user.go
+++ b/storage/user/info.go
@@ -16,6 +16,28 @@ import (
"gitlab.com/xx_network/primitives/id"
)
+type Proto struct {
+ //General Identity
+ TransmissionID *id.ID
+ TransmissionSalt []byte
+ TransmissionRSA *rsa.PrivateKey
+ ReceptionID *id.ID
+ ReceptionSalt []byte
+ ReceptionRSA *rsa.PrivateKey
+ Precanned bool
+ // Timestamp in which user has registered with the network
+ RegistrationTimestamp int64
+
+ RegCode string
+
+ TransmissionRegValidationSig []byte
+ ReceptionRegValidationSig []byte
+
+ //e2e Identity
+ E2eDhPrivateKey *cyclic.Int
+ E2eDhPublicKey *cyclic.Int
+}
+
type Info struct {
//General Identity
TransmissionID *id.ID
@@ -70,3 +92,28 @@ func NewUserFromBackup(backup *backup.Backup) Info {
E2eDhPublicKey: backup.ReceptionIdentity.DHPublicKey,
}
}
+
+func (u *User) PortableUserInfo() Info {
+ ci := u.CryptographicIdentity
+ return Info{
+ TransmissionID: ci.GetTransmissionID().DeepCopy(),
+ TransmissionSalt: copySlice(ci.GetTransmissionSalt()),
+ TransmissionRSA: ci.GetTransmissionRSA(),
+ ReceptionID: ci.GetReceptionID().DeepCopy(),
+ RegistrationTimestamp: u.GetRegistrationTimestamp().UnixNano(),
+ ReceptionSalt: copySlice(ci.GetReceptionSalt()),
+ ReceptionRSA: ci.GetReceptionRSA(),
+ Precanned: ci.IsPrecanned(),
+ //fixme: set these in the e2e layer, the command line layer
+ //needs more logical seperation so this can be removed
+ E2eDhPrivateKey: nil,
+ E2eDhPublicKey: nil,
+ }
+
+}
+
+func copySlice(s []byte) []byte {
+ n := make([]byte, len(s))
+ copy(n, s)
+ return n
+}
diff --git a/ud/utils_test.go b/ud/utils_test.go
index 425d22d9ae31775bc13b2efe6391037ba3a63f93..7d3b3626c3b479e0a14d87746ac707f970a7327e 100644
--- a/ud/utils_test.go
+++ b/ud/utils_test.go
@@ -15,6 +15,9 @@
package ud
import (
+ "testing"
+ "time"
+
"gitlab.com/elixxir/client/cmix/gateway"
"gitlab.com/elixxir/client/event"
"gitlab.com/elixxir/client/interfaces"
@@ -28,8 +31,6 @@ import (
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
- "testing"
- "time"
)
func newTestNetworkManager(t *testing.T) interfaces.NetworkManager {
@@ -76,7 +77,7 @@ func (tnm *testNetworkManager) SendManyCMIX([]message.TargetedCmixMessage, param
type dummyEventMgr struct{}
func (d *dummyEventMgr) Report(int, string, string, string) {}
-func (tnm *testNetworkManager) GetEventManager() event.Manager {
+func (tnm *testNetworkManager) GetEventManager() event.Reporter {
return &dummyEventMgr{}
}