diff --git a/api/client.go b/api/client.go
index 012e980a5d946c5dd632b896a9d26037d9b308bd..bd30a8bae5abb633f64956143edf38edf20036c2 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..31028bea0a2189597885cbd32d7b1d3384747890 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,39 @@ 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..a8c622832d39caae61e5081087f3524b90d41b30 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..cbf4b36a5830243fa57122134da9727a5fd62bd4 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/auth/verify.go b/auth/verify.go
index 66a86df6f125bb0abe7c28be4ecbb408603b0a98..1798e42be0781f19a1da2d9be1c9673c0d28f36d 100644
--- a/auth/verify.go
+++ b/auth/verify.go
@@ -18,3 +18,6 @@ func VerifyOwnership(received, verified contact.Contact, storage *storage.Sessio
return cAuth.VerifyOwnershipProof(myHistoricalPrivKey, verified.DhPubKey,
storage.E2e().GetGroup(), received.OwnershipProof)
}
+
+
+
diff --git a/dummy/send.go b/dummy/send.go
index 6cde639e97f776b485d599d5a2659771751e487f..96e9274cf84d8f9ad65faa3aa46dbe26df8568cc 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..a372f02c4c50fa32d72c4d1e394fef7b5d37662b
--- /dev/null
+++ b/interfaces/preimage/generate.go
@@ -0,0 +1,28 @@
+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..00a29f7384f4b864b14f323a319b49e184cc7934
--- /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..9688251fbbe1c4fe0240f67339b0ef75c78b8aa0
--- /dev/null
+++ b/interfaces/preimage/types.go
@@ -0,0 +1,14 @@
+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/message/sendE2E.go b/network/message/sendE2E.go
index 5f42729f651de44afa707d10b52d2d5c83caf428..f0d20c0687abceb72ecdc57aa31b7c3848168dac 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..b601640ea2e5774a48e1d7d7794f7adb5952b913 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}"
@@ -229,9 +229,37 @@ const relationshipFpLength = 15
// relationship fingerprints truncated to 15 characters.
func (m *Manager) GetRelationshipFingerprint() string {
// 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.receive.fingerprint,m.send.fingerprint}
+ }else{
+ fps = [][]byte{m.receive.fingerprint,m.send.fingerprint}
+ }
+
+ // Hash fingerprints
+ h, _ := blake2b.New256(nil)
+ for _, fp := range fps {
+ h.Write(fp)
+ }
+
+ // 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
+ var fps [][]byte
+
+
+ if bytes.Compare(m.receive.fingerprint, m.send.fingerprint)==1{
+ fps = [][]byte{m.receive.fingerprint,m.send.fingerprint}
+ }else{
+ fps = [][]byte{m.receive.fingerprint,m.send.fingerprint}
+ }
// Hash fingerprints
h, _ := blake2b.New256(nil)
@@ -240,5 +268,18 @@ 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_test.go b/storage/edge/edge_test.go
index 91bc215696b611ab0ea8c79df9d217cbd9c58c26..b03e3240601b95184e5976c70a789de9e8910be6 100644
--- a/storage/edge/edge_test.go
+++ b/storage/edge/edge_test.go
@@ -16,6 +16,7 @@ package edge
import (
"encoding/json"
+ "gitlab.com/elixxir/client/interfaces/preimage"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/primitives/id"
@@ -147,7 +148,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{identities[0].Bytes(), 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 +173,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{identities[1].Bytes(), 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()])
@@ -347,7 +348,7 @@ func TestStore_Get(t *testing.T) {
}
expected := Preimages{
- identities[0].String(): Preimage{identities[0].Bytes(), "default", identities[0].Bytes()},
+ identities[0].String(): Preimage{identities[0].Bytes(), preimage.Default, identities[0].Bytes()},
preimages[0].key(): preimages[0],
preimages[2].key(): preimages[2],
}
@@ -363,7 +364,7 @@ func TestStore_Get(t *testing.T) {
}
expected = Preimages{
- identities[1].String(): Preimage{identities[1].Bytes(), "default", identities[1].Bytes()},
+ identities[1].String(): Preimage{identities[1].Bytes(), preimage.Default, identities[1].Bytes()},
preimages[1].key(): preimages[1],
}
@@ -453,12 +454,12 @@ func TestLoadStore(t *testing.T) {
expectedPis := []Preimages{
{
- identities[0].String(): Preimage{identities[0].Bytes(), "default", identities[0].Bytes()},
+ identities[0].String(): Preimage{identities[0].Bytes(), preimage.Default, identities[0].Bytes()},
preimages[0].key(): preimages[0],
preimages[2].key(): preimages[2],
},
{
- identities[1].String(): Preimage{identities[1].Bytes(), "default", identities[1].Bytes()},
+ identities[1].String(): Preimage{identities[1].Bytes(), preimage.Default, identities[1].Bytes()},
preimages[1].key(): preimages[1],
},
}
diff --git a/storage/edge/preimage.go b/storage/edge/preimage.go
index f9e63a6417c5c8f81f7fc8cdffd237ee8885d923..0a10b1e6c17fb25891fbb37aa1e5cf3924213217 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"
@@ -33,8 +34,8 @@ type Preimages map[string]Preimage
func newPreimages(identity *id.ID) Preimages {
pis := Preimages{
identity.String(): {
- Data: identity[:],
- Type: "default",
+ Data: preimage.MakeDefault(identity),
+ Type: preimage.Default,
Source: identity[:],
},
}
diff --git a/storage/edge/preimage_test.go b/storage/edge/preimage_test.go
index c70d449f2e7be43bfa0cbebdbb0466baa61d83cf..b4f3c7ee781ff0b8ecf04b7b3e699bf19c9f9d37 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"
@@ -22,7 +23,7 @@ func Test_newPreimages(t *testing.T) {
identity := id.NewIdFromString("identity", id.User, t)
expected := Preimages{
identity.String(): {
- Data: identity.Bytes(),
+ Data: preimage.MakeDefault(identity),
Type: "default",
Source: identity.Bytes(),
},
@@ -42,17 +43,17 @@ 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(): {identity0.Bytes(), preimage.Default, preimage.MakeDefault(identity0)},
+ identity1.String(): {identity1.Bytes(), preimage.Group, identity1.Bytes()},
+ identity2.String(): {identity2.Bytes(), preimage.Default, identity2.Bytes()},
}
pis := newPreimages(identity0)
- exists := pis.add(Preimage{identity1.Bytes(), "group", identity1.Bytes()})
+ exists := pis.add(Preimage{identity1.Bytes(), preimage.Group, identity1.Bytes()})
if !exists {
t.Errorf("Failed to add idenetity.")
}
- exists = pis.add(Preimage{identity2.Bytes(), "default", identity2.Bytes()})
+ exists = pis.add(Preimage{identity2.Bytes(), preimage.Default, identity2.Bytes()})
if !exists {
t.Errorf("Failed to add idenetity.")
}
@@ -82,9 +83,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()})