diff --git a/api/authenticatedChannel.go b/api/authenticatedChannel.go
index 746572e94e73eb85c16dc60851adb04d901297a1..b302f78d46b81b9ebdb20d9f3e7e08f9ce2abb47 100644
--- a/api/authenticatedChannel.go
+++ b/api/authenticatedChannel.go
@@ -12,6 +12,8 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/auth"
"gitlab.com/elixxir/client/interfaces"
+ "gitlab.com/elixxir/client/interfaces/preimage"
+ "gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/primitives/fact"
"gitlab.com/xx_network/primitives/id"
@@ -103,6 +105,27 @@ func (c *Client) MakePrecannedAuthenticatedChannel(precannedID uint) (contact.Co
// 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: preimage.E2e,
+ Source: precan.ID[:],
+ }, me)
+
+ //rekey
+ c.storage.GetEdge().Add(edge.Preimage{
+ Data: sessionPartner.GetRekeyPreimage(),
+ Type: preimage.Rekey,
+ Source: precan.ID[:],
+ }, me)
+
return precan, err
}
diff --git a/api/client.go b/api/client.go
index 012e980a5d946c5dd632b896a9d26037d9b308bd..7919c62b869f1befb9a7567022bdc51475e8b4c2 100644
--- a/api/client.go
+++ b/api/client.go
@@ -13,12 +13,14 @@ import (
"gitlab.com/elixxir/client/auth"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/interfaces/user"
"gitlab.com/elixxir/client/keyExchange"
"gitlab.com/elixxir/client/network"
"gitlab.com/elixxir/client/registration"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/client/switchboard"
"gitlab.com/elixxir/comms/client"
"gitlab.com/elixxir/crypto/cyclic"
@@ -555,13 +557,45 @@ func (c *Client) GetNodeRegistrationStatus() (int, int, error) {
// 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)
- if err := c.storage.E2e().DeletePartner(partnerId); err != nil {
+ //get the partner so they can be removed from preiamge store
+ partner, err := c.storage.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.GetRekeyPreimage()
+
+ //delete the partner
+ if err = c.storage.E2e().DeletePartner(partnerId); err != nil {
return err
}
- if err := c.storage.Auth().Delete(partnerId); err != nil {
+ //delete the preimages
+ if err = c.storage.GetEdge().Remove(edge.Preimage{
+ Data: e2ePreimage,
+ Type: preimage.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: preimage.Rekey,
+ 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.Auth().Delete(partnerId); err != nil {
return err
}
+
+ //delete conversations
c.storage.Conversations().Delete(partnerId)
+
return nil
}
@@ -694,6 +728,13 @@ func checkVersionAndSetupStorage(def *ndf.NetworkDefinition, storageDir string,
err = storageSess.ForwardRegistrationStatus(storage.PermissioningComplete)
}
+ //add the request preiamge
+ storageSess.GetEdge().Add(edge.Preimage{
+ Data: preimage.GenerateRequest(protoUser.ReceptionID),
+ Type: preimage.Request,
+ Source: protoUser.ReceptionID[:],
+ }, protoUser.ReceptionID)
+
if err != nil {
return errors.WithMessage(err, "Failed to denote state "+
"change in session")
diff --git a/auth/callback.go b/auth/callback.go
index 4a5fba05b7e74335fd71bac6685db01126ae2527..e3d53fb47f4aa868ee23b27c757dd9d05145bb39 100644
--- a/auth/callback.go
+++ b/auth/callback.go
@@ -13,8 +13,10 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/message"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage/auth"
+ "gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/diffieHellman"
@@ -313,6 +315,38 @@ func (m *Manager) doConfirm(sr *auth.SentRequest, grp *cyclic.Group,
sr.GetPartner(), err)
}
+ //remove the confirm fingerprint
+ fp := sr.GetFingerprint()
+ if err := m.storage.GetEdge().Remove(edge.Preimage{
+ Data: preimage.Generate(fp[:], preimage.Confirm),
+ Type: preimage.Confirm,
+ Source: sr.GetPartner()[:],
+ }, m.storage.GetUser().ReceptionID); err != nil {
+ jww.WARN.Printf("Failed delete the preimage for confirm from %s: %+v",
+ sr.GetPartner(), err)
+ }
+
+ //add the e2e and rekey firngeprints
+ //e2e
+ sessionPartner, err := m.storage.E2e().GetPartner(sr.GetPartner())
+ if err != nil {
+ jww.FATAL.Panicf("Cannot find %s right after creating: %+v", sr.GetPartner(), err)
+ }
+ me := m.storage.GetUser().ReceptionID
+
+ m.storage.GetEdge().Add(edge.Preimage{
+ Data: sessionPartner.GetE2EPreimage(),
+ Type: preimage.E2e,
+ Source: sr.GetPartner()[:],
+ }, me)
+
+ //rekey
+ m.storage.GetEdge().Add(edge.Preimage{
+ Data: sessionPartner.GetRekeyPreimage(),
+ Type: preimage.Rekey,
+ Source: sr.GetPartner()[:],
+ }, me)
+
// delete the in progress negotiation
// this undoes the request lock
if err := m.storage.Auth().Delete(sr.GetPartner()); err != nil {
diff --git a/auth/confirm.go b/auth/confirm.go
index f13d3871d9669b52c66924cfb7e4f17bc89b080c..62216ed28935abe65db07f3fe6c313f3bd273b0c 100644
--- a/auth/confirm.go
+++ b/auth/confirm.go
@@ -13,7 +13,9 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/diffieHellman"
cAuth "gitlab.com/elixxir/crypto/e2e/auth"
@@ -87,6 +89,7 @@ func ConfirmRequestAuth(partner contact.Contact, rng io.Reader,
//get the fingerprint from the old ownership proof
fp := cAuth.MakeOwnershipProofFP(storedContact.OwnershipProof)
+ preimg := preimage.Generate(fp[:], preimage.Confirm)
//final construction
baseFmt.SetEcrPayload(ecrPayload)
@@ -114,6 +117,27 @@ func ConfirmRequestAuth(partner contact.Contact, rng io.Reader,
events.Report(10, "Auth", "SendConfirmError", em)
}
+ //add the preimages
+ sessionPartner, err := storage.E2e().GetPartner(partner.ID)
+ if err != nil {
+ jww.FATAL.Panicf("Cannot find %s right after creating: %+v", partner.ID, err)
+ }
+ me := storage.GetUser().ReceptionID
+
+ //e2e
+ storage.GetEdge().Add(edge.Preimage{
+ Data: sessionPartner.GetE2EPreimage(),
+ Type: preimage.E2e,
+ Source: partner.ID[:],
+ }, me)
+
+ //rekey
+ storage.GetEdge().Add(edge.Preimage{
+ Data: sessionPartner.GetRekeyPreimage(),
+ Type: preimage.Rekey,
+ Source: partner.ID[:],
+ }, me)
+
// delete the in progress negotiation
// this unlocks the request lock
//fixme - do these deletes at a later date
@@ -126,8 +150,10 @@ func ConfirmRequestAuth(partner contact.Contact, rng io.Reader,
jww.INFO.Printf("Confirming Auth with %s, msgDigest: %s",
partner.ID, cmixMsg.Digest())
+ param := params.GetDefaultCMIX()
+ param.IdentityPreimage = preimg
/*send message*/
- round, _, err := net.SendCMIX(cmixMsg, partner.ID, params.GetDefaultCMIX())
+ round, _, err := net.SendCMIX(cmixMsg, partner.ID, param)
if err != nil {
// if the send fails just set it to failed, it will but automatically
// retried
diff --git a/auth/request.go b/auth/request.go
index 1be24089150fd7ef7dcce0c6ffaaffb1324bab2e..d323eeec7de5b9d734b25a6bfccac8a327a0c10d 100644
--- a/auth/request.go
+++ b/auth/request.go
@@ -13,9 +13,11 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/auth"
"gitlab.com/elixxir/client/storage/e2e"
+ "gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/diffieHellman"
@@ -141,6 +143,12 @@ func RequestAuth(partner, me contact.Contact, message string, rng io.Reader,
cmixMsg.SetMac(mac)
cmixMsg.SetContents(baseFmt.Marshal())
+ storage.GetEdge().Add(edge.Preimage{
+ Data: preimage.Generate(confirmFp[:], preimage.Confirm),
+ Type: preimage.Confirm,
+ Source: partner.ID[:],
+ }, me.ID)
+
jww.TRACE.Printf("RequestAuth SALT: %v", salt)
jww.TRACE.Printf("RequestAuth ECRPAYLOAD: %v", baseFmt.GetEcrPayload())
jww.TRACE.Printf("RequestAuth MAC: %v", mac)
@@ -160,8 +168,9 @@ func RequestAuth(partner, me contact.Contact, message string, rng io.Reader,
partner.ID, cmixMsg.Digest())
/*send message*/
- round, _, err := net.SendCMIX(cmixMsg, partner.ID,
- params.GetDefaultCMIX())
+ p := params.GetDefaultCMIX()
+ p.IdentityPreimage = preimage.GenerateRequest(partner.ID)
+ round, _, err := net.SendCMIX(cmixMsg, partner.ID, p)
if err != nil {
// if the send fails just set it to failed, it will
// but automatically retried
diff --git a/bindings/notifications.go b/bindings/notifications.go
index 745dafb1b32d4b7aa00f3ab29043caee19cfe4bd..2274b096a5bb6b3969419f14538707243180ad23 100644
--- a/bindings/notifications.go
+++ b/bindings/notifications.go
@@ -15,26 +15,24 @@ import (
"gitlab.com/elixxir/crypto/fingerprint"
)
-
-type NotificationForMeReport struct{
- forMe bool
- tYpe string
+type NotificationForMeReport struct {
+ forMe bool
+ tYpe string
source []byte
}
-func (nfmr *NotificationForMeReport)ForMe()bool{
+func (nfmr *NotificationForMeReport) ForMe() bool {
return nfmr.forMe
}
-func (nfmr *NotificationForMeReport)Type()string{
+func (nfmr *NotificationForMeReport) Type() string {
return nfmr.tYpe
}
-func (nfmr *NotificationForMeReport)Source()[]byte{
+func (nfmr *NotificationForMeReport) Source() []byte {
return nfmr.source
}
-
// NotificationForMe Check if a notification received is for me
func NotificationForMe(messageHash, idFP string, preimages string) (*NotificationForMeReport, error) {
//handle message hash and idFP
@@ -48,15 +46,15 @@ func NotificationForMe(messageHash, idFP string, preimages string) (*Notificatio
}
//handle deserialization of preimages
- var preimageList edge.Preimages
- if err := json.Unmarshal([]byte(preimages),&preimageList); err!=nil{
- return nil, errors.WithMessagef(err,"Failed to unmarshal the preimages list, " +
+ var preimageList []edge.Preimage
+ if err := json.Unmarshal([]byte(preimages), &preimageList); err != nil {
+ return nil, errors.WithMessagef(err, "Failed to unmarshal the preimages list, "+
"cannot check if notification is for me")
}
//check if any preimages match with the passed in data
for _, preimage := range preimageList {
- if fingerprint.CheckIdentityFpFromMessageHash(idFpBytes, messageHashBytes, preimage.Data){
+ if fingerprint.CheckIdentityFpFromMessageHash(idFpBytes, messageHashBytes, preimage.Data) {
return &NotificationForMeReport{
forMe: true,
tYpe: preimage.Type,
diff --git a/bindings/preimage.go b/bindings/preimage.go
index 0540be51be4f89efaf90d9a91a7c55b58328fc70..38c2bf715ffa8b89a6e9bf266f963e352ff25937 100644
--- a/bindings/preimage.go
+++ b/bindings/preimage.go
@@ -6,34 +6,33 @@ import (
"gitlab.com/xx_network/primitives/id"
)
-
-type PreimageNotification interface{
+type PreimageNotification interface {
Notify(identity []byte, deleted bool)
}
-func (c *Client)RegisterPreimageCallback(identity []byte, pin PreimageNotification){
+func (c *Client) RegisterPreimageCallback(identity []byte, pin PreimageNotification) {
iid := &id.ID{}
copy(iid[:], identity)
- cb := func(localIdentity *id.ID, deleted bool){
- pin.Notify(localIdentity[:],deleted)
+ cb := func(localIdentity *id.ID, deleted bool) {
+ pin.Notify(localIdentity[:], deleted)
}
c.api.GetStorage().GetEdge().AddUpdateCallback(iid, cb)
}
-func (c *Client)GetPreimages(identity []byte)(string, error){
+func (c *Client) GetPreimages(identity []byte) (string, error) {
iid := &id.ID{}
copy(iid[:], identity)
list, exist := c.api.GetStorage().GetEdge().Get(iid)
- if !exist{
+ if !exist {
return "", errors.Errorf("Could not find a preimage list for %s", iid)
}
marshaled, err := json.Marshal(&list)
return string(marshaled), err
-}
\ No newline at end of file
+}
diff --git a/bindings/ud.go b/bindings/ud.go
index 900e102d75621c76d110732fca3c4011dfd23b8b..727f4118333c2813c8acd227000deffab78ad6e3 100644
--- a/bindings/ud.go
+++ b/bindings/ud.go
@@ -207,12 +207,11 @@ type MultiLookupCallback interface {
Callback(Succeeded *ContactList, failed *IdList, errors string)
}
-
-type lookupResponse struct{
- C contact.Contact
- err error
+type lookupResponse struct {
+ C contact.Contact
+ err error
index int
- id *id.ID
+ id *id.ID
}
// MultiLookup Looks for the contact object associated with all given userIDs.
@@ -223,12 +222,12 @@ type lookupResponse struct{
func (ud UserDiscovery) MultiLookup(ids *IdList, callback MultiLookupCallback,
timeoutMS int) error {
- idList := make([]*id.ID,0,ids.Len())
+ idList := make([]*id.ID, 0, ids.Len())
//extract all IDs from
- for i:=0;i<ids.Len();i++{
+ for i := 0; i < ids.Len(); i++ {
idBytes, err := ids.Get(i)
- if err!=nil{
+ if err != nil {
return errors.WithMessagef(err, "Failed to get ID at index %d", i)
}
uid, err := id.Unmarshal(idBytes)
@@ -245,54 +244,52 @@ func (ud UserDiscovery) MultiLookup(ids *IdList, callback MultiLookupCallback,
timeout := time.Duration(timeoutMS) * time.Millisecond
//loop through the IDs and send the lookup
- for i := range idList{
+ for i := range idList {
locali := i
localID := idList[locali]
- cb := func(c contact.Contact, err error){
+ cb := func(c contact.Contact, err error) {
results <- lookupResponse{
C: c,
err: err,
index: locali,
- id: localID,
+ id: localID,
}
}
- go func(){
+ go func() {
err := ud.ud.Lookup(localID, cb, timeout)
- if err!=nil{
+ if err != nil {
results <- lookupResponse{
- C: contact.Contact{},
- err: errors.WithMessagef(err, "Failed to send lookup " +
+ C: contact.Contact{},
+ err: errors.WithMessagef(err, "Failed to send lookup "+
"for user %s[%d]", localID, locali),
index: locali,
- id: localID,
+ id: localID,
}
}
}()
}
//run the result gathering in its own thread
- go func(){
- returnedContactList := make([]contact.Contact,0,len(idList))
- failedIDList := make([]*id.ID,0,len(idList))
+ go func() {
+ returnedContactList := make([]contact.Contact, 0, len(idList))
+ failedIDList := make([]*id.ID, 0, len(idList))
var concatonatedErrs string
//Get the responses and return
- for numReturned := 0; numReturned<len(idList);numReturned++{
- response := <- results
- if response.err==nil{
+ for numReturned := 0; numReturned < len(idList); numReturned++ {
+ response := <-results
+ if response.err == nil {
returnedContactList = append(returnedContactList, response.C)
- }else{
+ } else {
failedIDList = append(failedIDList, response.id)
- concatonatedErrs = concatonatedErrs + fmt.Sprintf("Error returned from " +
+ concatonatedErrs = concatonatedErrs + fmt.Sprintf("Error returned from "+
"send to %d [%d]:%+v\t", response.id, response.index, response.err)
}
}
- callback.Callback(&ContactList{list:returnedContactList}, &IdList{list:failedIDList}, concatonatedErrs)
+ callback.Callback(&ContactList{list: returnedContactList}, &IdList{list: failedIDList}, concatonatedErrs)
}()
-
return nil
}
-
diff --git a/cmd/root.go b/cmd/root.go
index 036ff66cf9fef36c45b79b114ce85a5de5774b59..23416872ee7e210fbe6b886bee12788a17d0e1bc 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -236,7 +236,7 @@ var rootCmd = &cobra.Command{
expectedCnt := viper.GetUint("receiveCount")
receiveCnt := uint(0)
waitSecs := viper.GetUint("waitTimeout")
- waitTimeout := time.Duration(waitSecs)* time.Second
+ waitTimeout := time.Duration(waitSecs) * time.Second
done := false
for !done && expectedCnt != 0 {
@@ -261,7 +261,7 @@ var rootCmd = &cobra.Command{
//wait an extra 5 seconds to make sure no messages were missed
done = false
- timer := time.NewTimer(5*time.Second)
+ timer := time.NewTimer(5 * time.Second)
for !done {
select {
case <-timer.C:
diff --git a/cmd/single.go b/cmd/single.go
index 6600cbfbbf9b9358d79163c555096127609379d2..27300ef1e6adb9965cc79682890df1ad6f0f7914 100644
--- a/cmd/single.go
+++ b/cmd/single.go
@@ -89,7 +89,7 @@ var singleCmd = &cobra.Command{
jww.FATAL.Panicf("Could not add single use process: %+v", err)
}
- for numReg, total := 1, 100; numReg < total; {
+ for numReg, total := 1, 100; numReg < (total*3)/4; {
time.Sleep(1 * time.Second)
numReg, total, err = client.GetNodeRegistrationStatus()
if err != nil {
diff --git a/dummy/send.go b/dummy/send.go
index 6cde639e97f776b485d599d5a2659771751e487f..f37f79927402b86f59606d901c0f2d393ff41b05 100644
--- a/dummy/send.go
+++ b/dummy/send.go
@@ -70,7 +70,16 @@ func (m *Manager) sendMessages(msgs map[id.ID]format.Message) error {
wg.Add(1)
go func(i int64, recipient id.ID, msg format.Message) {
- _, _, err := m.net.SendCMIX(msg, &recipient, params.GetDefaultCMIX())
+ //fill the preiamge with random data to ensure it isnt repeatable
+ p := params.GetDefaultCMIX()
+ p.IdentityPreimage = make([]byte, 32)
+ rng := m.rng.GetStream()
+ if _, err := rng.Read(p.IdentityPreimage); err != nil {
+ jww.FATAL.Panicf("Failed to generate data for random "+
+ "identity preimage in e2e send: %+v", err)
+ }
+ rng.Close()
+ _, _, err := m.net.SendCMIX(msg, &recipient, p)
if err != nil {
jww.WARN.Printf("failed to send dummy message %d/%d: %+v",
i, len(msgs), err)
diff --git a/groupChat/makeGroup.go b/groupChat/makeGroup.go
index e5137f56fd0bc45c8752c96f8244aaebe25fb365..a8f7773f9dc57feef95a5316fa193b7b83de799d 100644
--- a/groupChat/makeGroup.go
+++ b/groupChat/makeGroup.go
@@ -11,6 +11,7 @@ import (
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
gs "gitlab.com/elixxir/client/groupChat/groupStore"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/fastRNG"
@@ -92,7 +93,7 @@ func (m Manager) MakeGroup(membership []*id.ID, name, msg []byte) (gs.Group,
edgeStore := m.store.GetEdge()
edgeStore.Add(edge.Preimage{
Data: g.ID[:],
- Type: "group",
+ Type: preimage.Group,
Source: g.ID[:],
}, m.store.GetUser().ReceptionID)
}
diff --git a/groupChat/manager.go b/groupChat/manager.go
index 9c2f83249d9100f8433f7b9373b5d39897b575b2..7fffb109d44dadc435383d65424ac1b55b0f41b3 100644
--- a/groupChat/manager.go
+++ b/groupChat/manager.go
@@ -14,6 +14,7 @@ import (
gs "gitlab.com/elixxir/client/groupChat/groupStore"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/message"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/edge"
@@ -133,7 +134,7 @@ func (m Manager) JoinGroup(g gs.Group) error {
edgeStore := m.store.GetEdge()
edgeStore.Add(edge.Preimage{
Data: g.ID[:],
- Type: "group",
+ Type: preimage.Group,
Source: g.ID[:],
}, m.store.GetUser().ReceptionID)
@@ -151,7 +152,7 @@ func (m Manager) LeaveGroup(groupID *id.ID) error {
edgeStore := m.store.GetEdge()
err := edgeStore.Remove(edge.Preimage{
Data: groupID[:],
- Type: "group",
+ Type: preimage.Group,
Source: groupID[:],
}, m.store.GetUser().ReceptionID)
diff --git a/interfaces/preimage/generate.go b/interfaces/preimage/generate.go
new file mode 100644
index 0000000000000000000000000000000000000000..f410e087332478d09dcff8ce32c33af5a4263855
--- /dev/null
+++ b/interfaces/preimage/generate.go
@@ -0,0 +1,26 @@
+package preimage
+
+import (
+ "gitlab.com/xx_network/primitives/id"
+ "golang.org/x/crypto/blake2b"
+)
+
+func Generate(data []byte, t string) []byte {
+ // Hash fingerprints
+ h, _ := blake2b.New256(nil)
+ h.Write(data)
+ h.Write([]byte(t))
+
+ // Base 64 encode hash and truncate
+ return h.Sum(nil)
+}
+
+func GenerateRequest(recipient *id.ID) []byte {
+ // Hash fingerprints
+ h, _ := blake2b.New256(nil)
+ h.Write(recipient[:])
+ h.Write([]byte(Request))
+
+ // Base 64 encode hash and truncate
+ return h.Sum(nil)
+}
diff --git a/interfaces/preimage/request.go b/interfaces/preimage/request.go
new file mode 100644
index 0000000000000000000000000000000000000000..199c10909af8f723f2605dd4b5000d2072744b73
--- /dev/null
+++ b/interfaces/preimage/request.go
@@ -0,0 +1,24 @@
+package preimage
+
+import (
+ "gitlab.com/xx_network/primitives/id"
+ "golang.org/x/crypto/blake2b"
+)
+
+func MakeRequest(uid *id.ID) []byte {
+ h, _ := blake2b.New256(nil)
+ h.Write(uid[:])
+ h.Write([]byte(Request))
+
+ // Base 64 encode hash and truncate
+ return h.Sum(nil)
+}
+
+func MakeDefault(uid *id.ID) []byte {
+ h, _ := blake2b.New256(nil)
+ h.Write(uid[:])
+ h.Write([]byte(Default))
+
+ // Base 64 encode hash and truncate
+ return h.Sum(nil)
+}
diff --git a/interfaces/preimage/types.go b/interfaces/preimage/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..3588b4f24ca24ecdb5cc6840d35ade097b5468d8
--- /dev/null
+++ b/interfaces/preimage/types.go
@@ -0,0 +1,10 @@
+package preimage
+
+const (
+ Default = "default"
+ Request = "request"
+ Confirm = "confirm"
+ Rekey = "rekey"
+ E2e = "e2e"
+ Group = "group"
+)
diff --git a/keyExchange/rekey.go b/keyExchange/rekey.go
index 5acc9ba71f383b5e8ae15966421ecd227ed7f6e7..f549d7a57a69674565618048828b3a8586a42717 100644
--- a/keyExchange/rekey.go
+++ b/keyExchange/rekey.go
@@ -62,8 +62,10 @@ func trigger(instance *network.Instance, sendE2E interfaces.SendE2E,
"negotiating status: %s", session, session.NegotiationStatus())
}
+ rekeyPreimage := manager.GetRekeyPreimage()
+
// send the rekey notification to the partner
- err := negotiate(instance, sendE2E, sess, negotiatingSession, sendTimeout, stop)
+ err := negotiate(instance, sendE2E, sess, negotiatingSession, sendTimeout, rekeyPreimage, stop)
// if sending the negotiation fails, revert the state of the session to
// unconfirmed so it will be triggered in the future
if err != nil {
@@ -74,7 +76,7 @@ func trigger(instance *network.Instance, sendE2E interfaces.SendE2E,
func negotiate(instance *network.Instance, sendE2E interfaces.SendE2E,
sess *storage.Session, session *e2e.Session, sendTimeout time.Duration,
- stop *stoppable.Single) error {
+ rekeyPreimage []byte, stop *stoppable.Single) error {
e2eStore := sess.E2e()
//generate public key
@@ -103,6 +105,7 @@ func negotiate(instance *network.Instance, sendE2E interfaces.SendE2E,
//send the message under the key exchange
e2eParams := params.GetDefaultE2E()
e2eParams.Type = params.KeyExchange
+ e2eParams.IdentityPreimage = rekeyPreimage
rounds, _, _, err := sendE2E(m, e2eParams, stop)
// If the send fails, returns the error so it can be handled. The caller
diff --git a/keyExchange/trigger.go b/keyExchange/trigger.go
index 0bdcbcc6e6ca80a28b58f53bbf32f22a2b0d0d41..b4f6eb69c95707e1d330b255d10df6d3f6ae83e5 100644
--- a/keyExchange/trigger.go
+++ b/keyExchange/trigger.go
@@ -122,6 +122,7 @@ func handleTrigger(sess *storage.Session, net interfaces.NetworkManager,
//send the message under the key exchange
e2eParams := params.GetDefaultE2E()
+ e2eParams.IdentityPreimage = partner.GetRekeyPreimage()
// store in critical messages buffer first to ensure it is resent if the
// send fails
diff --git a/network/follow.go b/network/follow.go
index bdcdf5deb8d5bda9d72c587f2ceae7d20b80a0f8..9a33cd6c515685019f1f1375c5c28d6c2aa8240b 100644
--- a/network/follow.go
+++ b/network/follow.go
@@ -321,8 +321,8 @@ func (m *manager) follow(report interfaces.ClientErrorReport, rng csprng.Source,
//threshold is the earliest round that will not be excluded from earliest remaining
earliestRemaining, roundsWithMessages, roundsUnknown := gwRoundsState.RangeUnchecked(updated,
m.param.KnownRoundsThreshold, roundChecker)
- jww.DEBUG.Printf("Processed RangeUnchecked, Oldest: %d, firstUnchecked: %d, " +
- "last Checked: %d, threshold: %d, NewEarliestRemaning: %d, NumWithMessages: %d, " +
+ jww.DEBUG.Printf("Processed RangeUnchecked, Oldest: %d, firstUnchecked: %d, "+
+ "last Checked: %d, threshold: %d, NewEarliestRemaning: %d, NumWithMessages: %d, "+
"NumUnknown: %d", updated, gwRoundsState.GetFirstUnchecked(), gwRoundsState.GetLastChecked(),
m.param.KnownRoundsThreshold, earliestRemaining, len(roundsWithMessages), len(roundsUnknown))
diff --git a/network/message/handler.go b/network/message/handler.go
index a9a387b2c51e2324ffc6c0aafc73b79e79737465..838be7875a696a15f3074aee5fae07ce3b1f0679 100644
--- a/network/message/handler.go
+++ b/network/message/handler.go
@@ -11,6 +11,7 @@ import (
"fmt"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces/message"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage/edge"
"gitlab.com/elixxir/crypto/e2e"
@@ -52,28 +53,19 @@ func (m *Manager) handleMessage(ecrMsg format.Message, bundle Bundle, edge *edge
var err error
var relationshipFingerprint []byte
- //check if the identity fingerprint matches
- //first check if a list is present in store for the receiving source
- forMe := false
- preimagelist, exist := edge.Get(identity.Source)
- if exist{
- //if it exists, check against all in the list
- for key := range preimagelist{
- if forMe = fingerprint2.CheckIdentityFP(ecrMsg.GetIdentityFP(),
- ecrMsg.GetContents(), preimagelist[key].Data); forMe{
- break
- }
- }
- }else{
+ //if it exists, check against all in the list
+ has, forMe, _ := m.Session.GetEdge().Check(identity.Source, ecrMsg.GetIdentityFP(), ecrMsg.GetContents())
+ if !has {
+ jww.INFO.Printf("checking backup %v", preimage.MakeDefault(identity.Source))
//if it doesnt exist, check against the default fingerprint for the identity
forMe = fingerprint2.CheckIdentityFP(ecrMsg.GetIdentityFP(),
- ecrMsg.GetContents(), identity.Source[:])
+ ecrMsg.GetContents(), preimage.MakeDefault(identity.Source))
}
if !forMe {
if jww.GetLogThreshold() == jww.LevelTrace {
expectedFP := fingerprint2.IdentityFP(ecrMsg.GetContents(),
- identity.Source[:])
+ preimage.MakeDefault(identity.Source))
jww.TRACE.Printf("Message for %d (%s) failed identity "+
"check: %v (expected-default) vs %v (received)", identity.EphId,
identity.Source, expectedFP, ecrMsg.GetIdentityFP())
diff --git a/network/message/sendCmixUtils.go b/network/message/sendCmixUtils.go
index 7535a66d97f8b66396e92e2c3284e5ff6488a399..30fb94088c1b339462c87405e7b10e221299f3a2 100644
--- a/network/message/sendCmixUtils.go
+++ b/network/message/sendCmixUtils.go
@@ -11,6 +11,7 @@ import (
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces/params"
+ preimage2 "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/cmix"
pb "gitlab.com/elixxir/comms/mixmessages"
@@ -141,9 +142,13 @@ func buildSlotMessage(msg format.Message, recipient *id.ID, target *id.ID,
msg.SetEphemeralRID(ephIdFilled[:])
// use the alternate identity preimage if it is set
- preimage := recipient[:]
- if param.IdentityPreimage!=nil{
+ var preimage []byte
+ if param.IdentityPreimage != nil {
preimage = param.IdentityPreimage
+ jww.INFO.Printf("Sending to %s with override preimage %v", recipient, preimage)
+ }else{
+ preimage = preimage2.MakeDefault(recipient)
+ jww.INFO.Printf("Sending to %s with default preimage %v", recipient, preimage)
}
// Set the identity fingerprint
@@ -151,6 +156,8 @@ func buildSlotMessage(msg format.Message, recipient *id.ID, target *id.ID,
msg.SetIdentityFP(ifp)
+ jww.INFO.Printf(" Sending to %s with preimage %v, ifp: %v, contents: %v", recipient, preimage, ifp, msg.GetContents())
+
// Encrypt the message
salt := make([]byte, 32)
_, err = stream.Read(salt)
diff --git a/network/message/sendE2E.go b/network/message/sendE2E.go
index 5f42729f651de44afa707d10b52d2d5c83caf428..52d202393cc8817f2bf9ffd8acace69fb9df72eb 100644
--- a/network/message/sendE2E.go
+++ b/network/message/sendE2E.go
@@ -93,6 +93,11 @@ func (m *Manager) SendE2E(msg message.Send, param params.E2E,
jww.INFO.Printf("E2E sending %d/%d to %s with msgDigest: %s, key fp: %s",
i+i, len(partitions), msg.Recipient, msgEnc.Digest(), key.Fingerprint())
+ //set the preimage to the default e2e one if it is not already set
+ if param.IdentityPreimage == nil {
+ param.IdentityPreimage = partner.GetE2EPreimage()
+ }
+
//send the cmix message, each partition in its own thread
wg.Add(1)
go func(i int) {
diff --git a/storage/e2e/manager.go b/storage/e2e/manager.go
index a978beeae77c2fffa723c15f495ebf1fa4925c5c..68119395dc81f3c3dff50dfcfdd5b5d8b6da9ea4 100644
--- a/storage/e2e/manager.go
+++ b/storage/e2e/manager.go
@@ -14,13 +14,13 @@ import (
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/utility"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/crypto/cyclic"
dh "gitlab.com/elixxir/crypto/diffieHellman"
"gitlab.com/xx_network/primitives/id"
"golang.org/x/crypto/blake2b"
- "sort"
)
const managerPrefix = "Manager{partner:%s}"
@@ -228,10 +228,22 @@ const relationshipFpLength = 15
// relationship. The fingerprint is a base 64 encoded hash of of the two
// relationship fingerprints truncated to 15 characters.
func (m *Manager) GetRelationshipFingerprint() string {
+
+ // Base 64 encode hash and truncate
+ return base64.StdEncoding.EncodeToString(m.GetRelationshipFingerprintBytes())[:relationshipFpLength]
+}
+
+// GetRelationshipFingerprintBytes returns a unique fingerprint for an E2E
+// relationship. used for the e2e preimage.
+func (m *Manager) GetRelationshipFingerprintBytes() []byte {
// Sort fingerprints
- fps := [][]byte{m.receive.fingerprint, m.send.fingerprint}
- less := func(i, j int) bool { return bytes.Compare(fps[i], fps[j]) == -1 }
- sort.Slice(fps, less)
+ var fps [][]byte
+
+ if bytes.Compare(m.receive.fingerprint, m.send.fingerprint) == 1 {
+ fps = [][]byte{m.send.fingerprint, m.receive.fingerprint}
+ } else {
+ fps = [][]byte{m.receive.fingerprint, m.send.fingerprint}
+ }
// Hash fingerprints
h, _ := blake2b.New256(nil)
@@ -240,5 +252,17 @@ func (m *Manager) GetRelationshipFingerprint() string {
}
// Base 64 encode hash and truncate
- return base64.StdEncoding.EncodeToString(h.Sum(nil))[:relationshipFpLength]
+ return h.Sum(nil)
+}
+
+// GetE2EPreimage returns a hash of the unique
+// fingerprint for an E2E relationship message.
+func (m *Manager) GetE2EPreimage() []byte {
+ return preimage.Generate(m.GetRelationshipFingerprintBytes(), preimage.E2e)
+}
+
+// GetRekeyPreimage returns a hash of the unique
+// fingerprint for an E2E rekey message.
+func (m *Manager) GetRekeyPreimage() []byte {
+ return preimage.Generate(m.GetRelationshipFingerprintBytes(), preimage.Rekey)
}
diff --git a/storage/edge/edge.go b/storage/edge/edge.go
index 095780591630850d8e609e495c1c52647ae01648..a720055d73f95dcb8c70455cb16a40a3ba0f81b9 100644
--- a/storage/edge/edge.go
+++ b/storage/edge/edge.go
@@ -5,6 +5,7 @@ import (
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/storage/versioned"
+ fingerprint2 "gitlab.com/elixxir/crypto/fingerprint"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/netTime"
"sync"
@@ -146,12 +147,43 @@ func (s *Store) Remove(preimage Preimage, identity *id.ID) error {
}
// Get returns the Preimages list for the given identity.
-func (s *Store) Get(identity *id.ID) (Preimages, bool) {
+func (s *Store) Get(identity *id.ID) ([]Preimage, bool) {
s.mux.RLock()
defer s.mux.RUnlock()
preimages, exists := s.edge[*identity]
- return preimages, exists
+ if !exists {
+ return nil, false
+ }
+
+ preiamgesSlice := make([]Preimage, 0, len(preimages))
+
+ for _, preimage := range preimages {
+ preiamgesSlice = append(preiamgesSlice, preimage)
+ }
+ return preiamgesSlice, exists
+}
+
+// Check looks checks if the identity fingerprint matches for any of
+// the stored preimages. It returns the preimage it hit with if it
+// finds one.
+func (s *Store) Check(identity *id.ID, identityFP []byte, messageContents []byte) (bool, bool, Preimage) {
+ s.mux.RLock()
+ defer s.mux.RUnlock()
+
+ preimages, exists := s.edge[*identity]
+ if !exists {
+ return false, false, Preimage{}
+ }
+
+ for _, preimage := range preimages {
+ jww.INFO.Printf("checking ifp: %v, msg: %v, preimage %v", identityFP, messageContents, preimage)
+ if fingerprint2.CheckIdentityFP(identityFP, messageContents, preimage.Data) {
+ return true, true, preimage
+ }
+ }
+
+ return true, false, Preimage{}
}
// AddUpdateCallback adds the callback to be called for changes to the identity.
@@ -183,8 +215,8 @@ func LoadStore(kv *versioned.KV) (*Store, error) {
}
s := &Store{
- kv: kv,
- edge: make(map[id.ID]Preimages),
+ kv: kv,
+ edge: make(map[id.ID]Preimages),
callbacks: make(map[id.ID][]ListUpdateCallBack),
}
diff --git a/storage/edge/edge_test.go b/storage/edge/edge_test.go
index 91bc215696b611ab0ea8c79df9d217cbd9c58c26..e059e749666f0f30223e78e584a5af995a91092a 100644
--- a/storage/edge/edge_test.go
+++ b/storage/edge/edge_test.go
@@ -16,7 +16,9 @@ package edge
import (
"encoding/json"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/versioned"
+ fingerprint2 "gitlab.com/elixxir/crypto/fingerprint"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/primitives/id"
"math/rand"
@@ -147,7 +149,7 @@ func TestStore_Add(t *testing.T) {
"\nexpected: %d\nreceived: %d", identities[0], 3, len(pis))
}
- expected := Preimage{identities[0].Bytes(), "default", identities[0].Bytes()}
+ expected := Preimage{preimage.Generate(identities[0].Bytes(), preimage.Default), preimage.Default, identities[0].Bytes()}
if !reflect.DeepEqual(pis[expected.key()], expected) {
t.Errorf("First Preimage of first Preimages does not match expected."+
"\nexpected: %+v\nreceived: %+v", expected, pis[expected.key()])
@@ -172,7 +174,7 @@ func TestStore_Add(t *testing.T) {
"\nexpected: %d\nreceived: %d", identities[1], 2, len(pis))
}
- expected = Preimage{identities[1].Bytes(), "default", identities[1].Bytes()}
+ expected = Preimage{preimage.Generate(identities[1].Bytes(), preimage.Default), preimage.Default, identities[1].Bytes()}
if !reflect.DeepEqual(pis[expected.key()], expected) {
t.Errorf("First Preimage of second Preimages does not match expected."+
"\nexpected: %+v\nreceived: %+v", expected, pis[expected.key()])
@@ -290,9 +292,9 @@ func TestStore_Remove(t *testing.T) {
t.Errorf("Remove returned an error: %+v", err)
}
- if len(s.edge) != 2 {
+ if len(s.edge) != 3 {
t.Errorf("Length of edge incorrect.\nexpected: %d\nreceived: %d",
- 1, len(s.edge))
+ 2, len(s.edge))
}
pis := s.edge[*identities[0]]
@@ -316,9 +318,9 @@ func TestStore_Remove(t *testing.T) {
pis = s.edge[*identities[1]]
- if len(pis) != 0 {
+ if len(pis) != 1 {
t.Errorf("Length of preimages for identity %s inocrrect."+
- "\nexpected: %d\nreceived: %d", identities[1], 0, len(pis))
+ "\nexpected: %d\nreceived: %d", identities[1], 1, len(pis))
}
wg.Wait()
@@ -346,15 +348,25 @@ func TestStore_Get(t *testing.T) {
t.Errorf("No Preimages found for identity %s.", identities[0])
}
- expected := Preimages{
- identities[0].String(): Preimage{identities[0].Bytes(), "default", identities[0].Bytes()},
- preimages[0].key(): preimages[0],
- preimages[2].key(): preimages[2],
+ expected := []Preimage{
+ {preimage.Generate(identities[0].Bytes(), preimage.Default), preimage.Default, identities[0].Bytes()},
+ preimages[0],
+ preimages[2],
}
- if !reflect.DeepEqual(expected, pis) {
- t.Errorf("First Preimages for identity %s does not match expected."+
- "\nexpected: %+v\nreceived: %+v", identities[0], expected, pis)
+ if len(expected) != len(pis) {
+ t.Errorf("First Preimages for identity %s does not match expected, difrent lengths of %d and %d"+
+ "\nexpected: %+v\nreceived: %+v", identities[0], len(expected), len(pis), expected, pis)
+ }
+
+top:
+ for i, lookup := range expected {
+ for _, checked := range pis {
+ if reflect.DeepEqual(lookup, checked) {
+ continue top
+ }
+ }
+ t.Errorf("Entree %d in expected %v not found in received %v", i, lookup, pis)
}
pis, exists = s.Get(identities[1])
@@ -362,14 +374,24 @@ func TestStore_Get(t *testing.T) {
t.Errorf("No Preimages found for identity %s.", identities[1])
}
- expected = Preimages{
- identities[1].String(): Preimage{identities[1].Bytes(), "default", identities[1].Bytes()},
- preimages[1].key(): preimages[1],
+ expected = []Preimage{
+ {preimage.Generate(identities[1].Bytes(), preimage.Default), preimage.Default, identities[1].Bytes()},
+ preimages[1],
+ }
+
+ if len(expected) != len(pis) {
+ t.Errorf("First Preimages for identity %s does not match expected, difrent lengths of %d and %d"+
+ "\nexpected: %+v\nreceived: %+v", identities[0], len(expected), len(pis), expected, pis)
}
- if !reflect.DeepEqual(expected, pis) {
- t.Errorf("First Preimages for identity %s does not match expected."+
- "\nexpected: %+v\nreceived: %+v", identities[1], expected, pis)
+top2:
+ for i, lookup := range expected {
+ for _, checked := range pis {
+ if reflect.DeepEqual(lookup, checked) {
+ continue top2
+ }
+ }
+ t.Errorf("Entree %d in expected %v not found in received %v", i, lookup, pis)
}
}
@@ -451,15 +473,15 @@ func TestLoadStore(t *testing.T) {
t.Fatalf("LoadStore error: %v", err)
}
- expectedPis := []Preimages{
+ expectedPis := [][]Preimage{
{
- identities[0].String(): Preimage{identities[0].Bytes(), "default", identities[0].Bytes()},
- preimages[0].key(): preimages[0],
- preimages[2].key(): preimages[2],
+ Preimage{preimage.Generate(identities[0].Bytes(), preimage.Default), preimage.Default, identities[0].Bytes()},
+ preimages[0],
+ preimages[2],
},
{
- identities[1].String(): Preimage{identities[1].Bytes(), "default", identities[1].Bytes()},
- preimages[1].key(): preimages[1],
+ Preimage{preimage.Generate(identities[1].Bytes(), preimage.Default), preimage.Default, identities[1].Bytes()},
+ preimages[1],
},
}
@@ -469,11 +491,70 @@ func TestLoadStore(t *testing.T) {
t.Errorf("Identity %s does not exist in loaded store", identity)
}
- if !reflect.DeepEqual(pis, expectedPis[i]) {
- t.Errorf("Identity %s does not have expected preimages in loaded store."+
- "\nExpected: %v\nRecieved", expectedPis[i], pis)
+ if len(expectedPis[i]) != len(pis) {
+ t.Errorf("First Preimages for identity %s does not match expected, difrent lengths of %d and %d"+
+ "\nexpected: %+v\nreceived: %+v", identities[0], len(expectedPis[i]), len(pis), expectedPis[i], pis)
}
+
+ top:
+ for idx, lookup := range expectedPis[i] {
+ for _, checked := range pis {
+ if reflect.DeepEqual(lookup, checked) {
+ continue top
+ }
+ }
+ t.Errorf("Entree %d in expected %v not found in received %v", idx, lookup, pis)
+ }
+
+ }
+}
+
+func TestStore_Check(t *testing.T) {
+ // Initialize store
+ s, _, _ := newTestStore(t)
+ identities := []*id.ID{
+ id.NewIdFromString("identity0", id.User, t),
+ id.NewIdFromString("identity1", id.User, t),
+ }
+ preimages := []Preimage{
+ {[]byte("ID0"), "default0", []byte("ID0")},
+ {[]byte("ID1"), "default1", []byte("ID1")},
+ {[]byte("ID2"), "default2", []byte("ID2")},
+ }
+
+ // Add preimages
+ s.Add(preimages[0], identities[0])
+ s.Add(preimages[1], identities[1])
+ s.Add(preimages[2], identities[0])
+
+ testMsg := []byte("test message 123")
+ preImageData := preimages[0].Data
+ testFp := fingerprint2.IdentityFP(testMsg, preImageData)
+
+ has, forMe, receivedPreImage := s.Check(identities[0], testFp, testMsg)
+
+ if !has || !forMe || !reflect.DeepEqual(receivedPreImage, preimages[0]) {
+ t.Errorf("Unexpected result from Check()."+
+ "\nExpected results: (has: %v) "+
+ "\n\t(forMe: %v)"+
+ "\n\t(Preimage: %v)"+
+ "\nReceived results: (has: %v) "+
+ "\n\t(forME: %v)"+
+ "\n\t(Preimage: %v)", true, true, preimages[0],
+ has, forMe, receivedPreImage)
}
+
+ // Check with wrong identity (has should be true, for me false)
+ has, forMe, _ = s.Check(identities[1], testFp, testMsg)
+ if !has || forMe {
+ t.Errorf("Unexpected results from check."+
+ "\nExpected results: (has: %v)"+
+ "\n\t(ForMe %v)"+
+ "\nReceived results: "+
+ "has: %v"+
+ "\n\t(ForMe: %v)", true, false, has, forMe)
+ }
+
}
func TestStore_save(t *testing.T) {
diff --git a/storage/edge/preimage.go b/storage/edge/preimage.go
index f9e63a6417c5c8f81f7fc8cdffd237ee8885d923..a8e4c89432dddc25596495fe69b59e7786ceab45 100644
--- a/storage/edge/preimage.go
+++ b/storage/edge/preimage.go
@@ -4,6 +4,7 @@ import (
"encoding/base64"
"encoding/json"
"github.com/pkg/errors"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/netTime"
@@ -31,12 +32,13 @@ type Preimages map[string]Preimage
// newPreimages makes a Preimages object for the given identity and populates
// it with the default preimage for the identity. Does not store to disk.
func newPreimages(identity *id.ID) Preimages {
+ defaultPreimage := Preimage{
+ Data: preimage.MakeDefault(identity),
+ Type: preimage.Default,
+ Source: identity[:],
+ }
pis := Preimages{
- identity.String(): {
- Data: identity[:],
- Type: "default",
- Source: identity[:],
- },
+ defaultPreimage.key(): defaultPreimage,
}
return pis
diff --git a/storage/edge/preimage_test.go b/storage/edge/preimage_test.go
index c70d449f2e7be43bfa0cbebdbb0466baa61d83cf..b31cc4274075344ad705b5308e7ac30e93bac5d0 100644
--- a/storage/edge/preimage_test.go
+++ b/storage/edge/preimage_test.go
@@ -10,6 +10,7 @@ package edge
import (
"bytes"
"encoding/json"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/primitives/id"
@@ -20,12 +21,13 @@ import (
// Tests that newPreimages returns the expected new Preimages.
func Test_newPreimages(t *testing.T) {
identity := id.NewIdFromString("identity", id.User, t)
+ pimg := Preimage{
+ Data: preimage.MakeDefault(identity),
+ Type: "default",
+ Source: identity.Bytes(),
+ }
expected := Preimages{
- identity.String(): {
- Data: identity.Bytes(),
- Type: "default",
- Source: identity.Bytes(),
- },
+ pimg.key(): pimg,
}
received := newPreimages(identity)
@@ -42,36 +44,47 @@ func TestPreimages_add(t *testing.T) {
identity1 := id.NewIdFromString("identity1", id.User, t)
identity2 := id.NewIdFromString("identity3", id.User, t)
expected := Preimages{
- identity0.String(): {identity0.Bytes(), "default", identity0.Bytes()},
- identity1.String(): {identity1.Bytes(), "group", identity1.Bytes()},
- identity2.String(): {identity2.Bytes(), "default", identity2.Bytes()},
+ identity0.String(): {preimage.Generate(identity0.Bytes(), preimage.Default), preimage.Default, preimage.MakeDefault(identity0)},
+ identity1.String(): {preimage.Generate(identity1.Bytes(), preimage.Group), preimage.Group, identity1.Bytes()},
+ identity2.String(): {preimage.Generate(identity2.Bytes(), preimage.Default), preimage.Default, identity2.Bytes()},
}
pis := newPreimages(identity0)
- exists := pis.add(Preimage{identity1.Bytes(), "group", identity1.Bytes()})
+ preimageOne := Preimage{preimage.Generate(identity1.Bytes(), preimage.Group), preimage.Group, identity1.Bytes()}
+ exists := pis.add(preimageOne)
if !exists {
t.Errorf("Failed to add idenetity.")
}
- exists = pis.add(Preimage{identity2.Bytes(), "default", identity2.Bytes()})
+
+ preimageTwo := Preimage{preimage.Generate(identity2.Bytes(), preimage.Default), preimage.Default, identity2.Bytes()}
+ exists = pis.add(preimageTwo)
if !exists {
t.Errorf("Failed to add idenetity.")
}
- if !reflect.DeepEqual(expected, pis) {
- t.Errorf("Failed to add expected Preimages."+
- "\nexpected: %+v\nreceived: %+v", expected, pis)
+ for identity, pimg := range expected {
+ if _, exists = pis[pimg.key()]; !exists {
+ t.Errorf("Identity %s could not be found", identity)
+ }
}
+ expectedPreimageIdentityTwo := Preimage{
+ Data: preimage.Generate(identity2.Bytes(), preimage.Default),
+ Type: preimage.Default,
+ Source: identity2.Bytes(),
+ }
// Test that nothing happens when a Preimage with the same data exists
- exists = pis.add(Preimage{identity2.Bytes(), "test", identity2.Bytes()})
+ exists = pis.add(Preimage{preimage.Generate(identity2.Bytes(), preimage.Default), "test", identity2.Bytes()})
if exists {
t.Errorf("Add idenetity that shoudl already exist.")
}
- if !reflect.DeepEqual(expected, pis) {
- t.Errorf("Failed to add expected Preimages."+
- "\nexpected: %+v\nreceived: %+v", expected, pis)
+ receivedPreimageIdentityTwo := pis[preimageTwo.key()]
+
+ if !reflect.DeepEqual(expectedPreimageIdentityTwo, receivedPreimageIdentityTwo) {
+ t.Errorf("Unexpected overwritting of existing identity")
}
+
}
// Tests that Preimages.remove removes all the correct Preimage from the list.
@@ -82,9 +95,9 @@ func TestPreimages_remove(t *testing.T) {
// Add 10 Preimage to the list
for i := 0; i < 10; i++ {
identity := id.NewIdFromUInt(uint64(i), id.User, t)
- pisType := "default"
+ pisType := preimage.Default
if i%2 == 0 {
- pisType = "group"
+ pisType = preimage.Group
}
exists := pis.add(Preimage{identity.Bytes(), pisType, identity.Bytes()})