diff --git a/fileTransfer/fileMessage.go b/fileTransfer/fileMessage.go
deleted file mode 100644
index b73b948c90cc4d99bad2d459be6a8f98df61f2a5..0000000000000000000000000000000000000000
--- a/fileTransfer/fileMessage.go
+++ /dev/null
@@ -1,130 +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 fileTransfer
-
-import (
- "encoding/binary"
- "github.com/pkg/errors"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
-)
-
-// Size constants.
-const (
- paddingLen = ftCrypto.NonceSize // The length of the padding in bytes
- partNumLen = 2 // The length of the part number in bytes
- fmMinSize = partNumLen + paddingLen // Minimum size for the partMessage
-)
-
-// Error messages.
-const (
- newFmSizeErr = "size of external payload (%d) must be greater than %d"
- unmarshalFmSizeErr = "size of passed in bytes (%d) must be greater than %d"
- setFileFmErr = "length of part bytes (%d) must be smaller than maximum payload size %d"
-)
-
-/*
-+-----------------------------------------+
-| CMIX Message Contents |
-+---------+-------------+-----------------+
-| Padding | Part Number | File Data |
-| 8 bytes | 2 bytes | remaining space |
-+---------+-------------+-----------------+
-*/
-
-// partMessage contains part of the data being transferred and 256-bit padding
-// that is used as a nonce.
-type partMessage struct {
- data []byte // Serial of all contents
- padding []byte // Random padding bytes
- partNum []byte // The part number of the file
- part []byte // File part data
-}
-
-// newPartMessage generates a new part message that fits into the specified
-// external payload size. An error is returned if the external payload size is
-// too small to fit the part message.
-func newPartMessage(externalPayloadSize int) (partMessage, error) {
- if externalPayloadSize < fmMinSize {
- return partMessage{},
- errors.Errorf(newFmSizeErr, externalPayloadSize, fmMinSize)
- }
-
- return mapPartMessage(make([]byte, externalPayloadSize)), nil
-}
-
-// mapPartMessage maps the data to the components of a partMessage. It is mapped
-// by reference; a copy is not made.
-func mapPartMessage(data []byte) partMessage {
- return partMessage{
- data: data,
- padding: data[:paddingLen],
- partNum: data[paddingLen : paddingLen+partNumLen],
- part: data[paddingLen+partNumLen:],
- }
-}
-
-// unmarshalPartMessage converts the bytes into a partMessage. An error is
-// returned if the size of the data is too small for a partMessage.
-func unmarshalPartMessage(b []byte) (partMessage, error) {
- if len(b) < fmMinSize {
- return partMessage{},
- errors.Errorf(unmarshalFmSizeErr, len(b), fmMinSize)
- }
-
- return mapPartMessage(b), nil
-}
-
-// marshal returns the byte representation of the partMessage.
-func (m partMessage) marshal() []byte {
- return m.data
-}
-
-// getPadding returns the padding in the message.
-func (m partMessage) getPadding() []byte {
- return m.padding
-}
-
-// setPadding sets the partMessage padding to the given bytes. Note that this
-// padding should be random bytes generated via the appropriate crypto function.
-func (m partMessage) setPadding(b []byte) {
- copy(m.padding, b)
-}
-
-// getPartNum returns the file part number.
-func (m partMessage) getPartNum() uint16 {
- return binary.LittleEndian.Uint16(m.partNum)
-}
-
-// setPartNum sets the file part number.
-func (m partMessage) setPartNum(num uint16) {
- b := make([]byte, partNumLen)
- binary.LittleEndian.PutUint16(b, num)
- copy(m.partNum, b)
-}
-
-// getPart returns the file part data from the message.
-func (m partMessage) getPart() []byte {
- return m.part
-}
-
-// setPart sets the partMessage part to the given bytes. An error is returned if
-// the size of the provided part data is too large to store.
-func (m partMessage) setPart(b []byte) error {
- if len(b) > len(m.part) {
- return errors.Errorf(setFileFmErr, len(b), len(m.part))
- }
-
- copy(m.part, b)
-
- return nil
-}
-
-// getPartSize returns the number of bytes available to store part data.
-func (m partMessage) getPartSize() int {
- return len(m.part)
-}
diff --git a/fileTransfer/fileMessage_test.go b/fileTransfer/fileMessage_test.go
deleted file mode 100644
index 77b72eac9fa78a04d6c4c36aceda9a0effbd8a3e..0000000000000000000000000000000000000000
--- a/fileTransfer/fileMessage_test.go
+++ /dev/null
@@ -1,283 +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 fileTransfer
-
-import (
- "bytes"
- "encoding/binary"
- "fmt"
- "math/rand"
- "testing"
-)
-
-// Tests that newPartMessage returns a partMessage of the expected size.
-func Test_newPartMessage(t *testing.T) {
- externalPayloadSize := 256
-
- fm, err := newPartMessage(externalPayloadSize)
- if err != nil {
- t.Errorf("newPartMessage returned an error: %+v", err)
- }
-
- if len(fm.data) != externalPayloadSize {
- t.Errorf("Size of partMessage data does not match payload size."+
- "\nexpected: %d\nreceived: %d", externalPayloadSize, len(fm.data))
- }
-}
-
-// Error path: tests that newPartMessage returns the expected error when the
-// external payload size is too small.
-func Test_newPartMessage_SmallPayloadSizeError(t *testing.T) {
- externalPayloadSize := fmMinSize - 1
- expectedErr := fmt.Sprintf(newFmSizeErr, externalPayloadSize, fmMinSize)
-
- _, err := newPartMessage(externalPayloadSize)
- if err == nil || err.Error() != expectedErr {
- t.Errorf("newPartMessage did not return the expected error when the "+
- "given external payload size is too small."+
- "\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that mapPartMessage maps the data to the correct parts of the
-// partMessage.
-func Test_mapPartMessage(t *testing.T) {
- // Generate expected values
- _, expectedData, expectedPadding, expectedPartNum, expectedFile :=
- newRandomFileMessage()
-
- fm := mapPartMessage(expectedData)
-
- if !bytes.Equal(expectedData, fm.data) {
- t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
- expectedData, fm.data)
- }
-
- if !bytes.Equal(expectedPadding, fm.padding) {
- t.Errorf("Incorrect padding data.\nexpected: %q\nreceived: %q",
- expectedPadding, fm.padding)
- }
-
- if !bytes.Equal(expectedPartNum, fm.partNum) {
- t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
- expectedPartNum, fm.partNum)
- }
-
- if !bytes.Equal(expectedFile, fm.part) {
- t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.part)
- }
-
-}
-
-// Tests that unmarshalPartMessage returns a partMessage with the expected
-// values.
-func Test_unmarshalPartMessage(t *testing.T) {
- // Generate expected values
- _, expectedData, expectedPadding, expectedPartNumb, expectedFile :=
- newRandomFileMessage()
-
- fm, err := unmarshalPartMessage(expectedData)
- if err != nil {
- t.Errorf("unmarshalPartMessage return an error: %+v", err)
- }
-
- if !bytes.Equal(expectedData, fm.data) {
- t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
- expectedData, fm.data)
- }
-
- if !bytes.Equal(expectedPadding, fm.padding) {
- t.Errorf("Incorrect padding data.\nexpected: %q\nreceived: %q",
- expectedPadding, fm.padding)
- }
-
- if !bytes.Equal(expectedPartNumb, fm.partNum) {
- t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
- expectedPartNumb, fm.partNum)
- }
-
- if !bytes.Equal(expectedFile, fm.part) {
- t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.part)
- }
-}
-
-// Error path: tests that unmarshalPartMessage returns the expected error when
-// the provided data is too small to be unmarshalled into a partMessage.
-func Test_unmarshalPartMessage_SizeError(t *testing.T) {
- data := make([]byte, fmMinSize-1)
- expectedErr := fmt.Sprintf(unmarshalFmSizeErr, len(data), fmMinSize)
-
- _, err := unmarshalPartMessage(data)
- if err == nil || err.Error() != expectedErr {
- t.Errorf("unmarshalPartMessage did not return the expected error when "+
- "the given bytes are too small to be a partMessage."+
- "\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that partMessage.marshal returns the correct data.
-func Test_fileMessage_marshal(t *testing.T) {
- fm, expectedData, _, _, _ := newRandomFileMessage()
-
- data := fm.marshal()
-
- if !bytes.Equal(expectedData, data) {
- t.Errorf("Marshalled data does not match expected."+
- "\nexpected: %q\nreceived: %q", expectedData, data)
- }
-}
-
-// Tests that partMessage.getPadding returns the correct padding data.
-func Test_fileMessage_getPadding(t *testing.T) {
- fm, _, expectedPadding, _, _ := newRandomFileMessage()
-
- padding := fm.getPadding()
-
- if !bytes.Equal(expectedPadding, padding) {
- t.Errorf("Padding data does not match expected."+
- "\nexpected: %q\nreceived: %q", expectedPadding, padding)
- }
-}
-
-// Tests that partMessage.setPadding sets the correct data.
-func Test_fileMessage_setPadding(t *testing.T) {
- fm, err := newPartMessage(256)
- if err != nil {
- t.Errorf("Failed to create new partMessage: %+v", err)
- }
-
- expectedPadding := make([]byte, paddingLen)
- rand.New(rand.NewSource(42)).Read(expectedPadding)
-
- fm.setPadding(expectedPadding)
-
- if !bytes.Equal(expectedPadding, fm.getPadding()) {
- t.Errorf("Failed to set correct padding.\nexpected: %q\nreceived: %q",
- expectedPadding, fm.getPadding())
- }
-}
-
-// Tests that partMessage.getPartNum returns the correct part number.
-func Test_fileMessage_getPartNum(t *testing.T) {
- fm, _, _, expectedPartNum, _ := newRandomFileMessage()
-
- partNum := fm.getPartNum()
- expected := binary.LittleEndian.Uint16(expectedPartNum)
-
- if expected != partNum {
- t.Errorf("Part number does not match expected."+
- "\nexpected: %d\nreceived: %d", expected, partNum)
- }
-}
-
-// Tests that partMessage.setPartNum sets the correct part number.
-func Test_fileMessage_setPartNum(t *testing.T) {
- fm, err := newPartMessage(256)
- if err != nil {
- t.Errorf("Failed to create new partMessage: %+v", err)
- }
-
- expectedPartNum := make([]byte, partNumLen)
- rand.New(rand.NewSource(42)).Read(expectedPartNum)
- expected := binary.LittleEndian.Uint16(expectedPartNum)
-
- fm.setPartNum(expected)
-
- if expected != fm.getPartNum() {
- t.Errorf("Failed to set correct part number.\nexpected: %d\nreceived: %d",
- expected, fm.getPartNum())
- }
-}
-
-// Tests that partMessage.getPart returns the correct part data.
-func Test_fileMessage_getFile(t *testing.T) {
- fm, _, _, _, expectedFile := newRandomFileMessage()
-
- file := fm.getPart()
-
- if !bytes.Equal(expectedFile, file) {
- t.Errorf("File data does not match expected."+
- "\nexpected: %q\nreceived: %q", expectedFile, file)
- }
-}
-
-// Tests that partMessage.setPart sets the correct part data.
-func Test_fileMessage_setFile(t *testing.T) {
- fm, err := newPartMessage(256)
- if err != nil {
- t.Errorf("Failed to create new partMessage: %+v", err)
- }
-
- fileData := make([]byte, 64)
- rand.New(rand.NewSource(42)).Read(fileData)
- expectedFile := make([]byte, fm.getPartSize())
- copy(expectedFile, fileData)
-
- err = fm.setPart(expectedFile)
- if err != nil {
- t.Errorf("setPart returned an error: %+v", err)
- }
-
- if !bytes.Equal(expectedFile, fm.getPart()) {
- t.Errorf("Failed to set correct part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.getPart())
- }
-}
-
-// Error path: tests that partMessage.setPart returns the expected error when
-// the provided part data is too large for the message.
-func Test_fileMessage_setFile_FileTooLargeError(t *testing.T) {
- fm, err := newPartMessage(fmMinSize + 1)
- if err != nil {
- t.Errorf("Failed to create new partMessage: %+v", err)
- }
-
- expectedErr := fmt.Sprintf(setFileFmErr, fm.getPartSize()+1, fm.getPartSize())
-
- err = fm.setPart(make([]byte, fm.getPartSize()+1))
- if err == nil || err.Error() != expectedErr {
- t.Errorf("setPart did not return the expected error when the given "+
- "part data is too large to fit in the partMessage."+
- "\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that partMessage.getPartSize returns the expected available space for
-// the part data.
-func Test_fileMessage_getFileSize(t *testing.T) {
- expectedSize := 256
-
- fm, err := newPartMessage(fmMinSize + expectedSize)
- if err != nil {
- t.Errorf("Failed to create new partMessage: %+v", err)
- }
-
- if expectedSize != fm.getPartSize() {
- t.Errorf("File size incorrect.\nexpected: %d\nreceived: %d",
- expectedSize, fm.getPartSize())
- }
-}
-
-// newRandomFileMessage generates a new partMessage filled with random data and
-// return the partMessage and its individual parts.
-func newRandomFileMessage() (partMessage, []byte, []byte, []byte, []byte) {
- prng := rand.New(rand.NewSource(42))
- padding := make([]byte, paddingLen)
- prng.Read(padding)
- partNum := make([]byte, partNumLen)
- prng.Read(partNum)
- part := make([]byte, 64)
- prng.Read(part)
- data := append(append(padding, partNum...), part...)
-
- fm := mapPartMessage(data)
-
- return fm, data, padding, partNum, part
-}
diff --git a/fileTransfer/manager_test.go b/fileTransfer/manager_test.go
index c1133aa32a8f0f0e2fa09139678cdfd224e44fa2..63952f154487962fc6e504c56d58f6d0d00cda02 100644
--- a/fileTransfer/manager_test.go
+++ b/fileTransfer/manager_test.go
@@ -388,14 +388,13 @@ func TestManager_Resend_NoFingerprints(t *testing.T) {
func TestManager_CloseSend_NoFingerprints(t *testing.T) {
m, sti, _ := newTestManagerWithTransfers(
[]uint16{16}, false, false, nil, nil, nil, t)
- prng := NewPrng(42)
partSize, _ := m.getPartSize()
// Use up all the fingerprints in the transfer
transfer, _ := m.sent.GetTransfer(sti[0].tid)
for fpNum := uint16(0); fpNum < sti[0].numFps; fpNum++ {
partNum := fpNum % sti[0].numParts
- _, _, _, _, err := transfer.GetEncryptedPart(partNum, partSize, prng)
+ _, _, _, err := transfer.GetEncryptedPart(partNum, partSize+2)
if err != nil {
t.Errorf("Failed to encrypt part %d (%d): %+v", partNum, fpNum, err)
}
diff --git a/fileTransfer/receive.go b/fileTransfer/receive.go
index 9a70f5853212bae431653c096d9168d567008b2a..3552fdf5635a819f66cbecfb9945ca01ab529846 100644
--- a/fileTransfer/receive.go
+++ b/fileTransfer/receive.go
@@ -8,7 +8,6 @@
package fileTransfer
import (
- "github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces/message"
"gitlab.com/elixxir/client/stoppable"
@@ -64,16 +63,8 @@ func (m *Manager) readMessage(msg message.Receive) (format.Message, error) {
return cMixMsg, err
}
- // Unmarshal cMix message contents into a file part message
- partMsg, err := unmarshalPartMessage(cMixMsg.GetContents())
- if err != nil {
- return cMixMsg, errors.Errorf(unmarshalPartMessageErr, err)
- }
-
// Add part to received transfer
- rt, tid, completed, err := m.received.AddPart(partMsg.getPart(),
- partMsg.getPadding(), cMixMsg.GetMac(), partMsg.getPartNum(),
- cMixMsg.GetKeyFP())
+ rt, tid, completed, err := m.received.AddPart(cMixMsg)
if err != nil {
return cMixMsg, err
}
diff --git a/fileTransfer/receiveNew_test.go b/fileTransfer/receiveNew_test.go
index 872012beee4ed019a035212c85f45a16ea7a1926..4aea311faa6e0fedadf6f627e8f4b43eb544753e 100644
--- a/fileTransfer/receiveNew_test.go
+++ b/fileTransfer/receiveNew_test.go
@@ -51,7 +51,7 @@ func TestManager_receiveNewFileTransfer(t *testing.T) {
}
marshalledMsg, err := proto.Marshal(protoMsg)
if err != nil {
- t.Errorf("Failed to marshal proto message: %+v", err)
+ t.Errorf("Failed to Marshal proto message: %+v", err)
}
receiveMsg := message.Receive{
Payload: marshalledMsg,
@@ -120,7 +120,7 @@ func TestManager_receiveNewFileTransfer_Stop(t *testing.T) {
}
marshalledMsg, err := proto.Marshal(protoMsg)
if err != nil {
- t.Errorf("Failed to marshal proto message: %+v", err)
+ t.Errorf("Failed to Marshal proto message: %+v", err)
}
receiveMsg := message.Receive{
Payload: marshalledMsg,
diff --git a/fileTransfer/send.go b/fileTransfer/send.go
index d954811cd8495906b8c5519f8d07911f54113240..daeca373c1cba813f000840f39f747049db6262d 100644
--- a/fileTransfer/send.go
+++ b/fileTransfer/send.go
@@ -364,30 +364,14 @@ func (m *Manager) newCmixMessage(transfer *ftStorage.SentTransfer,
// Create new empty cMix message
cmixMsg := format.NewMessage(m.store.Cmix().GetGroup().GetP().ByteLen())
- // Create new empty file part message of size equal to the available payload
- // size in the cMix message
- partMsg, err := newPartMessage(cmixMsg.ContentsSize())
- if err != nil {
- return cmixMsg, err
- }
-
- // Get encrypted file part, file part MAC, padding (nonce), and fingerprint
- encPart, mac, padding, fp, err := transfer.GetEncryptedPart(
- partNum, partMsg.getPartSize(), rng)
- if err != nil {
- return cmixMsg, err
- }
-
- // Construct file part message from padding (
- partMsg.setPadding(padding)
- partMsg.setPartNum(partNum)
- err = partMsg.setPart(encPart)
+ // Get encrypted file part, file part MAC, nonce (nonce), and fingerprint
+ encPart, mac, fp, err := transfer.GetEncryptedPart(partNum, cmixMsg.ContentsSize())
if err != nil {
- return cmixMsg, err
+ return format.Message{}, err
}
// Construct cMix message
- cmixMsg.SetContents(partMsg.marshal())
+ cmixMsg.SetContents(encPart)
cmixMsg.SetKeyFP(fp)
cmixMsg.SetMac(mac)
@@ -566,12 +550,12 @@ func (m *Manager) getPartSize() (int, error) {
// Create new empty file part message of size equal to the available payload
// size in the cMix message
- partMsg, err := newPartMessage(cmixMsg.ContentsSize())
+ partMsg, err := ftStorage.NewPartMessage(cmixMsg.ContentsSize())
if err != nil {
return 0, err
}
- return partMsg.getPartSize(), nil
+ return partMsg.GetPartSize(), nil
}
// partitionFile splits the file into parts of the specified part size.
diff --git a/fileTransfer/send_test.go b/fileTransfer/send_test.go
index ee10658b1fe6c190cbaa9a04879c72829a726787..2e3d3d16d8325be32ba975decb14b3af41f57636 100644
--- a/fileTransfer/send_test.go
+++ b/fileTransfer/send_test.go
@@ -662,20 +662,20 @@ func TestManager_newCmixMessage(t *testing.T) {
"\nexpected: %s\nrecieved: %s", fp, cmixMsg.GetKeyFP())
}
- partMsg, err := unmarshalPartMessage(cmixMsg.GetContents())
+ decrPart, err := ftCrypto.DecryptPart(key, cmixMsg.GetContents(),
+ cmixMsg.GetMac(), 0,cmixMsg.GetKeyFP())
if err != nil {
- t.Errorf("Failed to unmarshal part message: %+v", err)
+ t.Errorf("Failed to decrypt file part: %+v", err)
}
- decrPart, err := ftCrypto.DecryptPart(key, partMsg.getPart(),
- partMsg.getPadding(), cmixMsg.GetMac(), partMsg.getPartNum())
+ partMsg, err := ftStorage.UnmarshalPartMessage(decrPart)
if err != nil {
- t.Errorf("Failed to decrypt file part: %+v", err)
+ t.Errorf("Failed to unmarshal part message: %+v", err)
}
- if !bytes.Equal(decrPart, parts[0]) {
+ if !bytes.Equal(partMsg.GetPart(), parts[0]) {
t.Errorf("Decrypted part does not match expected."+
- "\nexpected: %q\nreceived: %q", parts[0], decrPart)
+ "\nexpected: %q\nreceived: %q", parts[0], partMsg.GetPart())
}
}
@@ -998,7 +998,7 @@ func Test_makeListOfPartNums(t *testing.T) {
}
}
-// Tests that the part size returned by Manager.getPartSize matches the manually
+// Tests that the part size returned by Manager.GetPartSize matches the manually
// calculated part size.
func TestManager_getPartSize(t *testing.T) {
m := newTestManager(false, nil, nil, nil, nil, t)
@@ -1006,13 +1006,13 @@ func TestManager_getPartSize(t *testing.T) {
// Calculate the expected part size
primeByteLen := m.store.Cmix().GetGroup().GetP().ByteLen()
cmixMsgUsedLen := format.AssociatedDataSize
- filePartMsgUsedLen := fmMinSize
+ filePartMsgUsedLen := ftStorage.FmMinSize
expected := 2*primeByteLen - cmixMsgUsedLen - filePartMsgUsedLen-1
// Get the part size
partSize, err := m.getPartSize()
if err != nil {
- t.Errorf("getPartSize returned an error: %+v", err)
+ t.Errorf("GetPartSize returned an error: %+v", err)
}
if expected != partSize {
diff --git a/keyExchange/confirm.go b/keyExchange/confirm.go
index d754acc1da040efed8e55227d623c0cc5c414342..4c21f77db86638f24a50fcf65b65001e71e081c9 100644
--- a/keyExchange/confirm.go
+++ b/keyExchange/confirm.go
@@ -61,7 +61,7 @@ func handleConfirm(sess *storage.Session, confirmation message.Receive) {
confirmedSession := partner.GetSendSession(confimedSessionID)
if confirmedSession == nil {
jww.ERROR.Printf("[REKEY] Failed to find confirmed session %s from "+
- "partner %s: %s", confimedSessionID, confirmation.Sender, err)
+ "partner %s", confimedSessionID, confirmation.Sender)
return
}
diff --git a/storage/fileTransfer/fileMessage.go b/storage/fileTransfer/fileMessage.go
new file mode 100644
index 0000000000000000000000000000000000000000..03269326bbeab891e4678c888994fc35ea1026a6
--- /dev/null
+++ b/storage/fileTransfer/fileMessage.go
@@ -0,0 +1,119 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file //
+///////////////////////////////////////////////////////////////////////////////
+
+package fileTransfer
+
+import (
+ "encoding/binary"
+ "github.com/pkg/errors"
+)
+
+// Size constants.
+const (
+ partNumLen = 2 // The length of the part number in bytes
+ FmMinSize = partNumLen // Minimum size for the PartMessage
+)
+
+// Error messages.
+const (
+ newFmSizeErr = "size of external payload (%d) must be greater than %d"
+ unmarshalFmSizeErr = "size of passed in bytes (%d) must be greater than %d"
+ setFileFmErr = "length of part bytes (%d) must be smaller than maximum payload size %d"
+)
+
+/*
++-----------------------------------------+
+| CMIX Message Contents |
++---------+-------------+-----------------+
+| Padding | Part Number | File Data |
+| 8 bytes | 2 bytes | remaining space |
++---------+-------------+-----------------+
+*/
+
+// PartMessage contains part of the data being transferred and 256-bit nonce
+// that is used as a nonce.
+type PartMessage struct {
+ data []byte // Serial of all contents
+ partNum []byte // The part number of the file
+ part []byte // File part data
+}
+
+// NewPartMessage generates a new part message that fits into the specified
+// external payload size. An error is returned if the external payload size is
+// too small to fit the part message.
+func NewPartMessage(externalPayloadSize int) (PartMessage, error) {
+ if externalPayloadSize < FmMinSize {
+ return PartMessage{},
+ errors.Errorf(newFmSizeErr, externalPayloadSize, FmMinSize)
+ }
+
+ return MapPartMessage(make([]byte, externalPayloadSize)), nil
+}
+
+// MapPartMessage maps the data to the components of a PartMessage. It is mapped
+// by reference; a copy is not made.
+func MapPartMessage(data []byte) PartMessage {
+ return PartMessage{
+ data: data,
+ partNum: data[:partNumLen],
+ part: data[partNumLen:],
+ }
+}
+
+// UnmarshalPartMessage converts the bytes into a PartMessage. An error is
+// returned if the size of the data is too small for a PartMessage.
+func UnmarshalPartMessage(b []byte) (PartMessage, error) {
+ if len(b) < FmMinSize {
+ return PartMessage{},
+ errors.Errorf(unmarshalFmSizeErr, len(b), FmMinSize)
+ }
+
+ return MapPartMessage(b), nil
+}
+
+// Marshal returns the byte representation of the PartMessage.
+func (m PartMessage) Marshal() []byte {
+ b := make([]byte, len(m.data))
+ copy(b,m.data)
+ return b
+}
+
+// GetPartNum returns the file part number.
+func (m PartMessage) GetPartNum() uint16 {
+ return binary.LittleEndian.Uint16(m.partNum)
+}
+
+// SetPartNum sets the file part number.
+func (m PartMessage) SetPartNum(num uint16) {
+ b := make([]byte, partNumLen)
+ binary.LittleEndian.PutUint16(b, num)
+ copy(m.partNum, b)
+}
+
+// GetPart returns the file part data from the message.
+func (m PartMessage) GetPart() []byte {
+ b := make([]byte, len(m.part))
+ copy(b,m.part)
+ return b
+}
+
+// SetPart sets the PartMessage part to the given bytes. An error is returned if
+// the size of the provided part data is too large to store.
+func (m PartMessage) SetPart(b []byte) error {
+ if len(b) > len(m.part) {
+ return errors.Errorf(setFileFmErr, len(b), len(m.part))
+ }
+
+ copy(m.part, b)
+
+ return nil
+}
+
+// GetPartSize returns the number of bytes available to store part data.
+func (m PartMessage) GetPartSize() int {
+ return len(m.part)
+}
diff --git a/storage/fileTransfer/fileMessage_test.go b/storage/fileTransfer/fileMessage_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ad565931e6d44d60f887552e9cb4c1a954fe5cf0
--- /dev/null
+++ b/storage/fileTransfer/fileMessage_test.go
@@ -0,0 +1,241 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file //
+///////////////////////////////////////////////////////////////////////////////
+
+package fileTransfer
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "math/rand"
+ "testing"
+)
+
+// Tests that NewPartMessage returns a PartMessage of the expected size.
+func Test_newPartMessage(t *testing.T) {
+ externalPayloadSize := 256
+
+ fm, err := NewPartMessage(externalPayloadSize)
+ if err != nil {
+ t.Errorf("NewPartMessage returned an error: %+v", err)
+ }
+
+ if len(fm.data) != externalPayloadSize {
+ t.Errorf("Size of PartMessage data does not match payload size."+
+ "\nexpected: %d\nreceived: %d", externalPayloadSize, len(fm.data))
+ }
+}
+
+// Error path: tests that NewPartMessage returns the expected error when the
+// external payload size is too small.
+func Test_newPartMessage_SmallPayloadSizeError(t *testing.T) {
+ externalPayloadSize := FmMinSize - 1
+ expectedErr := fmt.Sprintf(newFmSizeErr, externalPayloadSize, FmMinSize)
+
+ _, err := NewPartMessage(externalPayloadSize)
+ if err == nil || err.Error() != expectedErr {
+ t.Errorf("NewPartMessage did not return the expected error when the "+
+ "given external payload size is too small."+
+ "\nexpected: %s\nreceived: %+v", expectedErr, err)
+ }
+}
+
+// Tests that MapPartMessage maps the data to the correct parts of the
+// PartMessage.
+func Test_mapPartMessage(t *testing.T) {
+ // Generate expected values
+ _, expectedData, expectedPartNum, expectedFile :=
+ newRandomFileMessage()
+
+ fm := MapPartMessage(expectedData)
+
+ if !bytes.Equal(expectedData, fm.data) {
+ t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
+ expectedData, fm.data)
+ }
+
+ if !bytes.Equal(expectedPartNum, fm.partNum) {
+ t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
+ expectedPartNum, fm.partNum)
+ }
+
+ if !bytes.Equal(expectedFile, fm.part) {
+ t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
+ expectedFile, fm.part)
+ }
+
+}
+
+// Tests that UnmarshalPartMessage returns a PartMessage with the expected
+// values.
+func Test_unmarshalPartMessage(t *testing.T) {
+ // Generate expected values
+ _, expectedData, expectedPartNumb, expectedFile :=
+ newRandomFileMessage()
+
+ fm, err := UnmarshalPartMessage(expectedData)
+ if err != nil {
+ t.Errorf("UnmarshalPartMessage return an error: %+v", err)
+ }
+
+ if !bytes.Equal(expectedData, fm.data) {
+ t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
+ expectedData, fm.data)
+ }
+
+ if !bytes.Equal(expectedPartNumb, fm.partNum) {
+ t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
+ expectedPartNumb, fm.partNum)
+ }
+
+ if !bytes.Equal(expectedFile, fm.part) {
+ t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
+ expectedFile, fm.part)
+ }
+}
+
+// Error path: tests that UnmarshalPartMessage returns the expected error when
+// the provided data is too small to be unmarshalled into a PartMessage.
+func Test_unmarshalPartMessage_SizeError(t *testing.T) {
+ data := make([]byte, FmMinSize-1)
+ expectedErr := fmt.Sprintf(unmarshalFmSizeErr, len(data), FmMinSize)
+
+ _, err := UnmarshalPartMessage(data)
+ if err == nil || err.Error() != expectedErr {
+ t.Errorf("UnmarshalPartMessage did not return the expected error when "+
+ "the given bytes are too small to be a PartMessage."+
+ "\nexpected: %s\nreceived: %+v", expectedErr, err)
+ }
+}
+
+// Tests that PartMessage.Marshal returns the correct data.
+func Test_fileMessage_marshal(t *testing.T) {
+ fm, expectedData, _, _ := newRandomFileMessage()
+
+ data := fm.Marshal()
+
+ if !bytes.Equal(expectedData, data) {
+ t.Errorf("Marshalled data does not match expected."+
+ "\nexpected: %q\nreceived: %q", expectedData, data)
+ }
+}
+
+// Tests that PartMessage.GetPartNum returns the correct part number.
+func Test_fileMessage_getPartNum(t *testing.T) {
+ fm, _, expectedPartNum, _ := newRandomFileMessage()
+
+ partNum := fm.GetPartNum()
+ expected := binary.LittleEndian.Uint16(expectedPartNum)
+
+ if expected != partNum {
+ t.Errorf("Part number does not match expected."+
+ "\nexpected: %d\nreceived: %d", expected, partNum)
+ }
+}
+
+// Tests that PartMessage.SetPartNum sets the correct part number.
+func Test_fileMessage_setPartNum(t *testing.T) {
+ fm, err := NewPartMessage(256)
+ if err != nil {
+ t.Errorf("Failed to create new PartMessage: %+v", err)
+ }
+
+ expectedPartNum := make([]byte, partNumLen)
+ rand.New(rand.NewSource(42)).Read(expectedPartNum)
+ expected := binary.LittleEndian.Uint16(expectedPartNum)
+
+ fm.SetPartNum(expected)
+
+ if expected != fm.GetPartNum() {
+ t.Errorf("Failed to set correct part number.\nexpected: %d\nreceived: %d",
+ expected, fm.GetPartNum())
+ }
+}
+
+// Tests that PartMessage.GetPart returns the correct part data.
+func Test_fileMessage_getFile(t *testing.T) {
+ fm, _, _, expectedFile := newRandomFileMessage()
+
+ file := fm.GetPart()
+
+ if !bytes.Equal(expectedFile, file) {
+ t.Errorf("File data does not match expected."+
+ "\nexpected: %q\nreceived: %q", expectedFile, file)
+ }
+}
+
+// Tests that PartMessage.SetPart sets the correct part data.
+func Test_fileMessage_setFile(t *testing.T) {
+ fm, err := NewPartMessage(256)
+ if err != nil {
+ t.Errorf("Failed to create new PartMessage: %+v", err)
+ }
+
+ fileData := make([]byte, 64)
+ rand.New(rand.NewSource(42)).Read(fileData)
+ expectedFile := make([]byte, fm.GetPartSize())
+ copy(expectedFile, fileData)
+
+ err = fm.SetPart(expectedFile)
+ if err != nil {
+ t.Errorf("SetPart returned an error: %+v", err)
+ }
+
+ if !bytes.Equal(expectedFile, fm.GetPart()) {
+ t.Errorf("Failed to set correct part data.\nexpected: %q\nreceived: %q",
+ expectedFile, fm.GetPart())
+ }
+}
+
+// Error path: tests that PartMessage.SetPart returns the expected error when
+// the provided part data is too large for the message.
+func Test_fileMessage_setFile_FileTooLargeError(t *testing.T) {
+ fm, err := NewPartMessage(FmMinSize + 1)
+ if err != nil {
+ t.Errorf("Failed to create new PartMessage: %+v", err)
+ }
+
+ expectedErr := fmt.Sprintf(setFileFmErr, fm.GetPartSize()+1, fm.GetPartSize())
+
+ err = fm.SetPart(make([]byte, fm.GetPartSize()+1))
+ if err == nil || err.Error() != expectedErr {
+ t.Errorf("SetPart did not return the expected error when the given "+
+ "part data is too large to fit in the PartMessage."+
+ "\nexpected: %s\nreceived: %+v", expectedErr, err)
+ }
+}
+
+// Tests that PartMessage.GetPartSize returns the expected available space for
+// the part data.
+func Test_fileMessage_getFileSize(t *testing.T) {
+ expectedSize := 256
+
+ fm, err := NewPartMessage(FmMinSize + expectedSize)
+ if err != nil {
+ t.Errorf("Failed to create new PartMessage: %+v", err)
+ }
+
+ if expectedSize != fm.GetPartSize() {
+ t.Errorf("File size incorrect.\nexpected: %d\nreceived: %d",
+ expectedSize, fm.GetPartSize())
+ }
+}
+
+// newRandomFileMessage generates a new PartMessage filled with random data and
+// return the PartMessage and its individual parts.
+func newRandomFileMessage() (PartMessage, []byte, []byte, []byte) {
+ prng := rand.New(rand.NewSource(42))
+ partNum := make([]byte, partNumLen)
+ prng.Read(partNum)
+ part := make([]byte, 64)
+ prng.Read(part)
+ data := append(partNum, part...)
+
+ fm := MapPartMessage(data)
+
+ return fm, data, partNum, part
+}
diff --git a/storage/fileTransfer/partStore_test.go b/storage/fileTransfer/partStore_test.go
index 5e3eabae208b88c8bfed5c2131727939c7c448e7..597fea4b20a6871cf44310e97cbd3c4f06c8aa59 100644
--- a/storage/fileTransfer/partStore_test.go
+++ b/storage/fileTransfer/partStore_test.go
@@ -12,6 +12,7 @@ import (
"encoding/binary"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/ekv"
+ "gitlab.com/elixxir/primitives/format"
"io"
"math/rand"
"reflect"
@@ -521,7 +522,10 @@ func Test_makePartsKey_consistency(t *testing.T) {
func newRandomPartStore(numParts uint16, kv *versioned.KV, prng io.Reader,
t *testing.T) (*partStore, []byte) {
- partSize := 64
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partSize := partData.GetPartSize()
ps, err := newPartStore(kv, numParts)
if err != nil {
diff --git a/storage/fileTransfer/receiveFileTransfers.go b/storage/fileTransfer/receiveFileTransfers.go
index ac9f262e6b2f6920fad1cf17a0453e3f89ace8c2..0c7bffdc6881e96fd79026deb58c98195b05dfbf 100644
--- a/storage/fileTransfer/receiveFileTransfers.go
+++ b/storage/fileTransfer/receiveFileTransfers.go
@@ -35,7 +35,7 @@ const (
getReceivedTransferErr = "received transfer with ID %s not found"
addTransferNewIdErr = "could not generate new transfer ID: %+v"
noFingerprintErr = "no part found with fingerprint %s"
- addPartErr = "failed to add part number %d/%d to transfer %s: %+v"
+ addPartErr = "failed to add part to transfer %s: %+v"
deleteReceivedTransferErr = "failed to delete received transfer with ID %s from store: %+v"
)
@@ -176,17 +176,18 @@ func (rft *ReceivedFileTransfersStore) DeleteTransfer(tid ftCrypto.TransferID) e
// transfer that the part was added to so that a progress callback can be
// called. Returns the transfer ID so that it can be used for logging. Also
// returns of the transfer is complete after adding the part.
-func (rft *ReceivedFileTransfersStore) AddPart(encryptedPart, padding,
- mac []byte, partNum uint16, fp format.Fingerprint) (*ReceivedTransfer,
+func (rft *ReceivedFileTransfersStore) AddPart(cmixMsg format.Message) (*ReceivedTransfer,
ftCrypto.TransferID, bool, error) {
rft.mux.Lock()
defer rft.mux.Unlock()
+ keyfp := cmixMsg.GetKeyFP()
+
// Lookup the part info for the given fingerprint
- info, exists := rft.info[fp]
+ info, exists := rft.info[cmixMsg.GetKeyFP()]
if !exists {
return nil, ftCrypto.TransferID{}, false,
- errors.Errorf(noFingerprintErr, fp)
+ errors.Errorf(noFingerprintErr, keyfp)
}
// Lookup the transfer with the ID in the part info
@@ -197,15 +198,14 @@ func (rft *ReceivedFileTransfersStore) AddPart(encryptedPart, padding,
}
// Add the part to the transfer
- completed, err := transfer.AddPart(
- encryptedPart, padding, mac, partNum, info.fpNum)
+ completed, err := transfer.AddPart(cmixMsg, info.fpNum)
if err != nil {
return transfer, info.id, false, errors.Errorf(
- addPartErr, partNum, transfer.numParts, info.id, err)
+ addPartErr, info.id, err)
}
// Remove the part info from the map
- delete(rft.info, fp)
+ delete(rft.info, keyfp)
return transfer, info.id, completed, nil
}
diff --git a/storage/fileTransfer/receiveFileTransfers_test.go b/storage/fileTransfer/receiveFileTransfers_test.go
index 0c048246023069538f20870b89a8a2dbb60d1d47..4fd245ec4d902d99f8389a8a4a1a6393c95d1432 100644
--- a/storage/fileTransfer/receiveFileTransfers_test.go
+++ b/storage/fileTransfer/receiveFileTransfers_test.go
@@ -345,14 +345,26 @@ func TestReceivedFileTransfersStore_AddPart(t *testing.T) {
}
// Create encrypted part
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
expectedData := []byte("test")
+
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(
- key, expectedData, fpNum, t)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(expectedData)
+
fp := ftCrypto.GenerateFingerprint(key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- rt, _, _, err := rft.AddPart(encryptedPart, padding, mac, partNum, fp)
+ rt, _, _, err := rft.AddPart(cmixMsg)
if err != nil {
t.Errorf("AddPart returned an error: %+v", err)
}
@@ -373,9 +385,9 @@ func TestReceivedFileTransfersStore_AddPart(t *testing.T) {
// Check that the correct part was stored
receivedPart := expectedRT.receivedParts.parts[partNum]
- if !bytes.Equal(receivedPart, expectedData) {
+ if !bytes.Equal(receivedPart[:len(expectedData)], expectedData) {
t.Errorf("Part in memory is not expected."+
- "\nexpected: %q\nreceived: %q", expectedData, receivedPart)
+ "\nexpected: %q\nreceived: %q", expectedData, receivedPart[:len(expectedData)])
}
}
@@ -391,9 +403,12 @@ func TestReceivedFileTransfersStore_AddPart_NoFingerprintError(t *testing.T) {
// Create encrypted part
fp := format.NewFingerprint([]byte("invalidTransferKey"))
+ msg := format.NewMessage(1000)
+ msg.SetKeyFP(fp)
+
// Add encrypted part
expectedErr := fmt.Sprintf(noFingerprintErr, fp)
- _, _, _, err = rft.AddPart([]byte{}, []byte{}, []byte{}, 0, fp)
+ _, _, _, err = rft.AddPart(msg)
if err == nil || err.Error() != expectedErr {
t.Errorf("AddPart did not return the expected error when no part for "+
"the fingerprint exists.\nexpected: %s\nreceived: %+v",
@@ -425,9 +440,12 @@ func TestReceivedFileTransfersStore_AddPart_NoTransferError(t *testing.T) {
invalidTid, _ := ftCrypto.NewTransferID(prng)
rft.info[fp].id = invalidTid
+ msg := format.NewMessage(1000)
+ msg.SetKeyFP(fp)
+
// Add encrypted part
expectedErr := fmt.Sprintf(getReceivedTransferErr, invalidTid)
- _, _, _, err = rft.AddPart([]byte{}, []byte{}, []byte{}, 0, fp)
+ _, _, _, err = rft.AddPart(msg)
if err == nil || err.Error() != expectedErr {
t.Errorf("AddPart did not return the expected error when no transfer "+
"for the ID exists.\nexpected: %s\nreceived: %+v", expectedErr, err)
@@ -455,14 +473,24 @@ func TestReceivedFileTransfersStore_AddPart_AddPartError(t *testing.T) {
// Create encrypted part
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart := []byte("invalidPart")
- mac = []byte("invalidMAC")
- padding := make([]byte, 24)
+ part := []byte("invalidPart")
+ mac = make([]byte, format.MacLen)
fp := ftCrypto.GenerateFingerprint(key, fpNum)
// Add encrypted part
- expectedErr := fmt.Sprintf(addPartErr, partNum, numParts, tid, "")
- _, _, _, err = rft.AddPart(encryptedPart, padding, mac, partNum, fp)
+ expectedErr := fmt.Sprintf(addPartErr, tid, "")
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(part)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(partData.Marshal())
+ cmixMsg.SetMac(mac)
+
+ _, _, _, err = rft.AddPart(cmixMsg)
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Errorf("AddPart did not return the expected error when the "+
"encrypted part, padding, and MAC are invalid."+
diff --git a/storage/fileTransfer/receiveTransfer.go b/storage/fileTransfer/receiveTransfer.go
index df4bad66163245c9593bfbbc949d73ccf04b5bc3..0d2f638d81d684d9ff7b3eca3505a6c8af3eceb0 100644
--- a/storage/fileTransfer/receiveTransfer.go
+++ b/storage/fileTransfer/receiveTransfer.go
@@ -10,12 +10,14 @@ package fileTransfer
import (
"bytes"
"encoding/binary"
+ "fmt"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/storage/utility"
"gitlab.com/elixxir/client/storage/versioned"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
+ "gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/primitives/netTime"
"sync"
"time"
@@ -276,20 +278,25 @@ func (rt *ReceivedTransfer) AddProgressCB(
// AddPart decrypts an encrypted file part, adds it to the list of received
// parts and marks its fingerprint as used. Returns true if the part added was
// the last in the transfer.
-func (rt *ReceivedTransfer) AddPart(encryptedPart, padding, mac []byte, partNum,
+func (rt *ReceivedTransfer) AddPart(cmixMsg format.Message,
fpNum uint16) (bool, error) {
rt.mux.Lock()
defer rt.mux.Unlock()
// Decrypt the encrypted file part
- decryptedPart, err := ftCrypto.DecryptPart(
- rt.key, encryptedPart, padding, mac, fpNum)
+ decryptedPart, err := ftCrypto.DecryptPart(rt.key,
+ cmixMsg.GetContents(), cmixMsg.GetMac(), fpNum, cmixMsg.GetKeyFP())
+ if err != nil {
+ return false, err
+ }
+
+ part, err := UnmarshalPartMessage(decryptedPart)
if err != nil {
return false, err
}
// Add the part to the list of parts
- err = rt.receivedParts.addPart(decryptedPart, partNum)
+ err = rt.receivedParts.addPart(part.GetPart(), part.GetPartNum())
if err != nil {
return false, err
}
@@ -298,7 +305,7 @@ func (rt *ReceivedTransfer) AddPart(encryptedPart, padding, mac []byte, partNum,
rt.fpVector.Use(uint32(fpNum))
// Mark part as received
- rt.receivedStatus.Use(uint32(partNum))
+ rt.receivedStatus.Use(uint32(part.GetPartNum()))
if rt.receivedStatus.GetNumUsed() >= uint32(rt.numParts) {
return true, nil
@@ -322,6 +329,8 @@ func (rt *ReceivedTransfer) GetFile() ([]byte, error) {
// Remove extra data added when sending as parts
fileData = fileData[:rt.fileSize]
+ fmt.Println(fileData)
+
if !ftCrypto.VerifyTransferMAC(fileData, rt.key, rt.transferMAC) {
return fileData, errors.New(getTransferMacErr)
}
diff --git a/storage/fileTransfer/receiveTransfer_test.go b/storage/fileTransfer/receiveTransfer_test.go
index 7c0382ec2f038899e9f1d047b087e958e0795abc..281bb373822ee0642a6c02c07c814d402cd3d174 100644
--- a/storage/fileTransfer/receiveTransfer_test.go
+++ b/storage/fileTransfer/receiveTransfer_test.go
@@ -16,6 +16,7 @@ import (
"gitlab.com/elixxir/client/storage/versioned"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/ekv"
+ "gitlab.com/elixxir/primitives/format"
"reflect"
"strings"
"sync"
@@ -538,13 +539,25 @@ func TestReceivedTransfer_AddPart(t *testing.T) {
_, rt, _ := newEmptyReceivedTransfer(16, 20, kv, t)
// Create encrypted part
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
expectedData := []byte("test")
+
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(
- rt.key, expectedData, fpNum, t)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(expectedData)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- complete, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ complete, err := rt.AddPart(cmixMsg,fpNum)
if err != nil {
t.Errorf("AddPart returned an error: %+v", err)
}
@@ -556,9 +569,9 @@ func TestReceivedTransfer_AddPart(t *testing.T) {
receivedData, exists := rt.receivedParts.parts[partNum]
if !exists {
t.Errorf("Part #%d not found in part map.", partNum)
- } else if !bytes.Equal(expectedData, receivedData) {
+ } else if !bytes.Equal(expectedData, receivedData[:len(expectedData)]) {
t.Fatalf("Part data in list does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expectedData, receivedData)
+ "\nexpected: %+v\nreceived: %+v", expectedData, receivedData[:len(expectedData)])
}
// Check that the fingerprint vector has correct values
@@ -594,14 +607,27 @@ func TestReceivedTransfer_AddPart_DecryptPartError(t *testing.T) {
_, rt, _ := newEmptyReceivedTransfer(16, 20, kv, t)
// Create encrypted part
- Data := []byte("test")
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ expectedData := []byte("test")
+
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, _, padding := newEncryptedPartData(rt.key, Data, fpNum, t)
- mac := []byte("invalidMAC")
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(expectedData)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, _, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+ badMac := make([]byte, format.MacLen)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(badMac)
// Add encrypted part
expectedErr := "reconstructed MAC from decrypting does not match MAC from sender"
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = rt.AddPart(cmixMsg, fpNum)
if err == nil || err.Error() != expectedErr {
t.Errorf("AddPart did not return the expected error when the MAC is "+
"invalid.\nexpected: %s\nreceived: %+v", expectedErr, err)
@@ -670,11 +696,22 @@ func Test_loadReceivedTransfer(t *testing.T) {
// Create encrypted part
expectedData := []byte("test")
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(
- expectedRT.key, expectedData, fpNum, t)
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(expectedData)
+
+ fp := ftCrypto.GenerateFingerprint(expectedRT.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(expectedRT.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- _, err := expectedRT.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = expectedRT.AddPart(cmixMsg, fpNum)
if err != nil {
t.Errorf("Failed to add test part: %+v", err)
}
@@ -712,12 +749,25 @@ func Test_loadReceivedTransfer_LoadFpVectorError(t *testing.T) {
tid, rt, _ := newRandomReceivedTransfer(16, 20, kv, t)
// Create encrypted part
+
data := []byte("test")
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(rt.key, data, fpNum, t)
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(data)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = rt.AddPart(cmixMsg, fpNum)
if err != nil {
t.Errorf("Failed to add test part: %+v", err)
}
@@ -746,10 +796,22 @@ func Test_loadReceivedTransfer_LoadPartStoreError(t *testing.T) {
// Create encrypted part
data := []byte("test")
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(rt.key, data, fpNum, t)
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(data)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = rt.AddPart(cmixMsg, fpNum)
if err != nil {
t.Errorf("Failed to add test part: %+v", err)
}
@@ -778,10 +840,22 @@ func Test_loadReceivedTransfer_LoadReceivedVectorError(t *testing.T) {
// Create encrypted part
data := []byte("test")
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(rt.key, data, fpNum, t)
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(data)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = rt.AddPart(cmixMsg, fpNum)
if err != nil {
t.Errorf("Failed to add test part: %+v", err)
}
@@ -871,11 +945,22 @@ func TestReceivedTransfer_delete(t *testing.T) {
// Create encrypted part
expectedData := []byte("test")
partNum, fpNum := uint16(1), uint16(1)
- encryptedPart, mac, padding := newEncryptedPartData(
- rt.key, expectedData, fpNum, t)
+
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(expectedData)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, fpNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), fpNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
// Add encrypted part
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, fpNum)
+ _, err = rt.AddPart(cmixMsg, fpNum)
if err != nil {
t.Fatalf("Failed to add test part: %+v", err)
}
@@ -1030,8 +1115,20 @@ func newRandomReceivedTransfer(numParts, numFps uint16, kv *versioned.KV,
}
for partNum, part := range parts.parts {
- encryptedPart, mac, padding := newEncryptedPartData(key, part, partNum, t)
- _, err := rt.AddPart(encryptedPart, padding, mac, partNum, partNum)
+ cmixMsg := format.NewMessage(format.MinimumPrimeSize)
+
+ partData, _ := NewPartMessage(cmixMsg.ContentsSize())
+ partData.SetPartNum(partNum)
+ _ = partData.SetPart(part)
+
+ fp := ftCrypto.GenerateFingerprint(rt.key, partNum)
+ encryptedPart, mac, err := ftCrypto.EncryptPart(rt.key, partData.Marshal(), partNum, fp)
+
+ cmixMsg.SetKeyFP(fp)
+ cmixMsg.SetContents(encryptedPart)
+ cmixMsg.SetMac(mac)
+
+ _, err = rt.AddPart(cmixMsg, partNum)
if err != nil {
t.Errorf("Failed to add part #%d: %+v", partNum, err)
}
@@ -1059,18 +1156,4 @@ func newEmptyReceivedTransfer(numParts, numFps uint16, kv *versioned.KV,
}
return tid, rt, fileData
-}
-
-// newEncryptedPartData encrypts the part data and returns the encrypted part
-// its MAC, and its padding.
-func newEncryptedPartData(key ftCrypto.TransferKey, part []byte, fpNum uint16,
- t *testing.T) ([]byte, []byte, []byte) {
- // Create encrypted part
- prng := NewPrng(42)
- encPart, mac, padding, err := ftCrypto.EncryptPart(key, part, fpNum, prng)
- if err != nil {
- t.Fatalf("Failed to encrypt data: %+v", err)
- }
-
- return encPart, mac, padding
-}
+}
\ No newline at end of file
diff --git a/storage/fileTransfer/sentTransfer.go b/storage/fileTransfer/sentTransfer.go
index 35b8a450f738d78c8aaef199d858d7e1f21abaf3..cdffaaeca6807c4025b9bf90925130e6be9cbcb5 100644
--- a/storage/fileTransfer/sentTransfer.go
+++ b/storage/fileTransfer/sentTransfer.go
@@ -17,7 +17,6 @@ import (
"gitlab.com/elixxir/client/storage/versioned"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/netTime"
"sync"
@@ -427,31 +426,44 @@ func (st *SentTransfer) AddProgressCB(cb interfaces.SentProgressCallback,
// GetEncryptedPart gets the specified part, encrypts it, and returns the
// encrypted part along with its MAC, padding, and fingerprint.
-func (st *SentTransfer) GetEncryptedPart(partNum uint16, partSize int,
- rng csprng.Source) (encPart, mac, padding []byte, fp format.Fingerprint,
- err error) {
+func (st *SentTransfer) GetEncryptedPart(partNum uint16, contentsSize int) (encPart, mac []byte,
+ fp format.Fingerprint, err error) {
st.mux.Lock()
defer st.mux.Unlock()
+ // Create new empty file part message of size equal to the available payload
+ // size in the cMix message
+ partMsg, err := NewPartMessage(contentsSize)
+ if err != nil {
+ return nil, nil, format.Fingerprint{}, err
+ }
+
+ partMsg.SetPartNum(partNum)
+
// Lookup part
part, exists := st.sentParts.getPart(partNum)
if !exists {
- return nil, nil, nil, format.Fingerprint{},
+ return nil, nil, format.Fingerprint{},
errors.Errorf(noPartNumErr, partNum)
}
+ if err = partMsg.SetPart(part); err != nil{
+ return nil, nil, format.Fingerprint{},
+ err
+ }
+
// If all fingerprints have been used but parts still remain, then change
// the status to stopping and return an error specifying that all the
// retries have been used
if st.fpVector.GetNumAvailable() < 1 {
st.status = Stopping
- return nil, nil, nil, format.Fingerprint{}, MaxRetriesErr
+ return nil, nil, format.Fingerprint{}, MaxRetriesErr
}
// Get next unused fingerprint number and mark it as used
nextKey, err := st.fpVector.Next()
if err != nil {
- return nil, nil, nil, format.Fingerprint{},
+ return nil, nil, format.Fingerprint{},
errors.Errorf(fingerprintErr, err)
}
fpNum := uint16(nextKey)
@@ -460,16 +472,13 @@ func (st *SentTransfer) GetEncryptedPart(partNum uint16, partSize int,
fp = ftCrypto.GenerateFingerprint(st.key, fpNum)
// Encrypt the file part and generate the file part MAC and padding (nonce)
- maxLengthPart := make([]byte, partSize)
- copy(maxLengthPart, part)
- encPart, mac, padding, err = ftCrypto.EncryptPart(
- st.key, maxLengthPart, fpNum, rng)
+ encPart, mac, err = ftCrypto.EncryptPart(st.key, partMsg.Marshal(), fpNum, fp)
if err != nil {
- return nil, nil, nil, format.Fingerprint{},
+ return nil, nil, format.Fingerprint{},
errors.Errorf(encryptPartErr, partNum, err)
}
- return encPart, mac, padding, fp, err
+ return encPart, mac, fp, err
}
// SetInProgress adds the specified file part numbers to the in-progress
diff --git a/storage/fileTransfer/sentTransfer_test.go b/storage/fileTransfer/sentTransfer_test.go
index da835f58a6c16aa6bf2955584b441d710d0bb8d5..033992bf84b42aa4bf54431ac50e3c3c0b132998 100644
--- a/storage/fileTransfer/sentTransfer_test.go
+++ b/storage/fileTransfer/sentTransfer_test.go
@@ -803,7 +803,6 @@ func TestSentTransfer_AddProgressCB(t *testing.T) {
func TestSentTransfer_GetEncryptedPart(t *testing.T) {
kv := versioned.NewKV(make(ekv.Memstore))
_, st := newRandomSentTransfer(16, 24, kv, t)
- prng := NewPrng(42)
// Create and fill fingerprint map used to check fingerprint validity
// The first item in the uint16 slice is the fingerprint number and the
@@ -816,7 +815,7 @@ func TestSentTransfer_GetEncryptedPart(t *testing.T) {
for i := uint16(0); i < st.numFps; i++ {
partNum := i % st.numParts
- encPart, mac, padding, fp, err := st.GetEncryptedPart(partNum, 16, prng)
+ encPart, mac, fp, err := st.GetEncryptedPart(partNum, 18)
if err != nil {
t.Fatalf("GetEncryptedPart returned an error for part number "+
"%d (%d): %+v", partNum, i, err)
@@ -836,17 +835,24 @@ func TestSentTransfer_GetEncryptedPart(t *testing.T) {
}
// Attempt to decrypt the part
- part, err := ftCrypto.DecryptPart(st.key, encPart, padding, mac, fpNum[0])
+ partMarshaled, err := ftCrypto.DecryptPart(st.key, encPart, mac, fpNum[0], fp)
if err != nil {
t.Errorf("Failed to decrypt file part number %d (%d): %+v",
partNum, i, err)
}
+ partMsg, _ := UnmarshalPartMessage(partMarshaled)
+
// Make sure the decrypted part matches the original
expectedPart, _ := st.sentParts.getPart(i % st.numParts)
- if !bytes.Equal(expectedPart, part) {
+ if !bytes.Equal(expectedPart, partMsg.GetPart()) {
t.Errorf("Decyrpted part number %d does not match expected (%d)."+
- "\nexpected: %+v\nreceived: %+v", partNum, i, expectedPart, part)
+ "\nexpected: %+v\nreceived: %+v", partNum, i, expectedPart, partMsg.GetPart())
+ }
+
+ if partMsg.GetPartNum()!=i % st.numParts{
+ t.Errorf("Number of part did not match, expected: %d, " +
+ "received: %d", i % st.numParts, partMsg.GetPartNum())
}
}
}
@@ -856,12 +862,11 @@ func TestSentTransfer_GetEncryptedPart(t *testing.T) {
func TestSentTransfer_GetEncryptedPart_NoPartError(t *testing.T) {
kv := versioned.NewKV(make(ekv.Memstore))
_, st := newRandomSentTransfer(16, 24, kv, t)
- prng := NewPrng(42)
partNum := st.numParts + 1
expectedErr := fmt.Sprintf(noPartNumErr, partNum)
- _, _, _, _, err := st.GetEncryptedPart(partNum, 16, prng)
+ _, _, _, err := st.GetEncryptedPart(partNum, 16)
if err == nil || err.Error() != expectedErr {
t.Errorf("GetEncryptedPart did not return the expected error for a "+
"nonexistent part number %d.\nexpected: %s\nreceived: %+v",
@@ -874,12 +879,11 @@ func TestSentTransfer_GetEncryptedPart_NoPartError(t *testing.T) {
func TestSentTransfer_GetEncryptedPart_NoFingerprintsError(t *testing.T) {
kv := versioned.NewKV(make(ekv.Memstore))
_, st := newRandomSentTransfer(16, 24, kv, t)
- prng := NewPrng(42)
// Use up all the fingerprints
for i := uint16(0); i < st.numFps; i++ {
partNum := i % st.numParts
- _, _, _, _, err := st.GetEncryptedPart(partNum, 16, prng)
+ _, _, _, err := st.GetEncryptedPart(partNum, 18)
if err != nil {
t.Errorf("Error when encyrpting part number %d (%d): %+v",
partNum, i, err)
@@ -887,7 +891,7 @@ func TestSentTransfer_GetEncryptedPart_NoFingerprintsError(t *testing.T) {
}
// Try to encrypt without any fingerprints
- _, _, _, _, err := st.GetEncryptedPart(5, 16, prng)
+ _, _, _, err := st.GetEncryptedPart(5, 18)
if err != MaxRetriesErr {
t.Errorf("GetEncryptedPart did not return MaxRetriesErr when all "+
"fingerprints have been used.\nexpected: %s\nreceived: %+v",
@@ -895,32 +899,6 @@ func TestSentTransfer_GetEncryptedPart_NoFingerprintsError(t *testing.T) {
}
}
-// Error path: tests that SentTransfer.GetEncryptedPart returns the expected
-// error when encrypting the part fails due to a PRNG error.
-func TestSentTransfer_GetEncryptedPart_EncryptPartError(t *testing.T) {
- kv := versioned.NewKV(make(ekv.Memstore))
- _, st := newRandomSentTransfer(16, 24, kv, t)
- prng := NewPrngErr()
-
- // Create and fill fingerprint map used to check fingerprint validity
- // The first item in the uint16 slice is the fingerprint number and the
- // second item is the number of times it has been used
- fpMap := make(map[format.Fingerprint][]uint16, st.numFps)
- for num, fp := range ftCrypto.GenerateFingerprints(st.key, st.numFps) {
- fpMap[fp] = []uint16{uint16(num), 0}
- }
-
- partNum := uint16(0)
- expectedErr := fmt.Sprintf(encryptPartErr, partNum, "")
-
- _, _, _, _, err := st.GetEncryptedPart(partNum, 16, prng)
- if err == nil || !strings.Contains(err.Error(), expectedErr) {
- t.Errorf("GetEncryptedPart did not return the expected error when "+
- "the PRNG should have errored.\nexpected: %s\nreceived: %+v",
- expectedErr, err)
- }
-}
-
// Tests that SentTransfer.SetInProgress correctly adds the part numbers for the
// given round ID to the in-progress map and sets the correct parts as
// in-progress in the state vector.