Skip to content
Snippets Groups Projects
Commit 37890353 authored by Richard T. Carback III's avatar Richard T. Carback III
Browse files

Remove unnecessary load/save password functions

parent d1745728
No related branches found
No related tags found
3 merge requests!510Release,!232Modify restructure branch to make it ready for merge to release,!207WIP: Client Restructure
Hide whitespace changes
Inline Side-by-side
backup/backup.go
+ 3
− 17
View file @ 37890353
......@@ -30,9 +30,6 @@ const (
errSavePassword = "failed to save password: %+v"
errSaveKeySaltParams = "failed to save key, salt, and params: %+v"
// ResumeBackup
errLoadPassword = "backup not initialized: load user password failed: %+v"
// Backup.StopBackup
errDeletePassword = "failed to delete password: %+v"
errDeleteCrypto = "failed to delete key, salt, and parameters: %+v"
......@@ -106,12 +103,6 @@ func InitializeBackup(password string, updateBackupCb UpdateBackupFn,
rng: rng,
}
// Save password to storage
err := savePassword(password, b.kv)
if err != nil {
return nil, errors.Errorf(errSavePassword, err)
}
// Derive key and get generated salt and parameters
rand := b.rng.GetStream()
salt, err := backup.MakeSalt(rand)
......@@ -147,9 +138,9 @@ func InitializeBackup(password string, updateBackupCb UpdateBackupFn,
func ResumeBackup(updateBackupCb UpdateBackupFn, container *messenger.Container,
e2e E2e, session Session, ud UserDiscovery, kv *versioned.KV,
rng *fastRNG.StreamGenerator) (*Backup, error) {
_, err := loadPassword(kv)
_, _, _, err := loadBackup(store.GetKV())
if err != nil {
return nil, errors.Errorf(errLoadPassword, err)
return nil, err
}
b := &Backup{
......@@ -253,12 +244,7 @@ func (b *Backup) StopBackup() error {
defer b.mux.Unlock()
b.updateBackupCb = nil
err := deletePassword(b.kv)
if err != nil {
return errors.Errorf(errDeletePassword, err)
}
err = deleteBackup(b.kv)
err := deleteBackup(b.store.GetKV())
if err != nil {
return errors.Errorf(errDeleteCrypto, err)
}
......
backup/backup_test.go
+ 9
− 41
View file @ 37890353
......@@ -15,6 +15,7 @@ import (
"time"
"gitlab.com/elixxir/client/api/messenger"
"gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/ekv"
......@@ -44,16 +45,6 @@ func Test_InitializeBackup(t *testing.T) {
t.Error("Timed out waiting for callback.")
}
// Check that the correct password is in storage
loadedPassword, err := loadPassword(b.kv)
if err != nil {
t.Errorf("Failed to load password: %+v", err)
}
if expectedPassword != loadedPassword {
t.Errorf("Loaded invalid key.\nexpected: %q\nreceived: %q",
expectedPassword, loadedPassword)
}
// Check that the key, salt, and params were saved to storage
key, salt, _, err := loadBackup(b.kv)
if err != nil {
......@@ -121,18 +112,8 @@ func Test_ResumeBackup(t *testing.T) {
t.Errorf("ResumeBackup returned an error: %+v", err)
}
// Check that the correct password is in storage
loadedPassword, err := loadPassword(b.kv)
if err != nil {
t.Errorf("Failed to load password: %+v", err)
}
if expectedPassword != loadedPassword {
t.Errorf("Loaded invalid key.\nexpected: %q\nreceived: %q",
expectedPassword, loadedPassword)
}
// get key, salt, and parameters of resumed backup
key2, salt2, _, err := loadBackup(b.kv)
// Get key, salt, and parameters of resumed backup
key2, salt2, _, err := loadBackup(b.store.GetKV())
if err != nil {
t.Errorf("Failed to load key, salt, and params from resumed "+
"backup: %+v", err)
......@@ -164,12 +145,10 @@ func Test_ResumeBackup(t *testing.T) {
// Error path: Tests that ResumeBackup returns an error if no password is
// present in storage.
func Test_ResumeBackup_NoKeyError(t *testing.T) {
expectedErr := strings.Split(errLoadPassword, "%")[0]
kv := versioned.NewKV(ekv.MakeMemstore())
rngGen := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
_, err := ResumeBackup(nil, &messenger.Container{}, newMockE2e(t), newMockSession(t),
newMockUserDiscovery(), kv, rngGen)
func Test_resumeBackup_NoKeyError(t *testing.T) {
expectedErr := "object not found"
s := storage.InitTestingSession(t)
_, err := resumeBackup(nil, nil, s, &interfaces.BackupContainer{}, nil)
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Errorf("ResumeBackup did not return the expected error when no "+
"password is present.\nexpected: %s\nreceived: %+v", expectedErr, err)
......@@ -181,13 +160,8 @@ func Test_ResumeBackup_NoKeyError(t *testing.T) {
func TestBackup_TriggerBackup(t *testing.T) {
cbChan := make(chan []byte)
cb := func(encryptedBackup []byte) { cbChan <- encryptedBackup }
b := newTestBackup("MySuperSecurePassword", cb, t)
// get password
password, err := loadPassword(b.kv)
if err != nil {
t.Errorf("Failed to load password from storage: %+v", err)
}
password := "MySuperSecurePassword"
b := newTestBackup(password, cb, t)
collatedBackup := b.assembleBackup()
......@@ -265,12 +239,6 @@ func TestBackup_StopBackup(t *testing.T) {
case <-time.After(10 * time.Millisecond):
}
// Make sure password is deleted
password, err := loadPassword(b.kv)
if err == nil || len(password) != 0 {
t.Errorf("Loaded password that should be deleted: %q", password)
}
// Make sure key, salt, and params are deleted
key, salt, p, err := loadBackup(b.kv)
if err == nil || len(key) != 0 || len(salt) != 0 || p != (backup.Params{}) {
......
backup/keyStorage.go
+ 1
− 26
View file @ 37890353
......@@ -9,6 +9,7 @@ package backup
import (
"bytes"
"github.com/pkg/errors"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/crypto/backup"
......@@ -100,29 +101,3 @@ func unmarshalBackup(buf []byte) (key, salt []byte, params backup.Params, err er
return
}
// savePassword saves the user's backup password to storage.
func savePassword(password string, kv *versioned.KV) error {
obj := &versioned.Object{
Version: passwordStorageVersion,
Timestamp: netTime.Now(),
Data: []byte(password),
}
return kv.Set(passwordStorageKey, passwordStorageVersion, obj)
}
// loadPassword returns the user's backup password from storage.
func loadPassword(kv *versioned.KV) (string, error) {
obj, err := kv.Get(passwordStorageKey, passwordStorageVersion)
if err != nil {
return "", err
}
return string(obj.Data), nil
}
// deletePassword deletes the user's backup password from storage.
func deletePassword(kv *versioned.KV) error {
return kv.Delete(passwordStorageKey, passwordStorageVersion)
}
backup/keyStorage_test.go deleted 100644 → 0
+ 0
− 95
View file @ d1745728
////////////////////////////////////////////////////////////////////////////////
// Copyright © 2020 xx network SEZC //
// //
// Use of this source code is governed by a license that can be found in the //
// LICENSE file //
////////////////////////////////////////////////////////////////////////////////
package backup
import (
"testing"
"gitlab.com/elixxir/client/storage/versioned"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/primitives/netTime"
)
// Tests that savePassword saves the password to storage by loading it and
// comparing it to the original.
func Test_savePassword(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
expectedPassword := "MySuperSecurePassword"
// Save the password
err := savePassword(expectedPassword, kv)
if err != nil {
t.Errorf("savePassword returned an error: %+v", err)
}
// Attempt to load the password
obj, err := kv.Get(passwordStorageKey, passwordStorageVersion)
if err != nil {
t.Errorf("Failed to get password from storage: %+v", err)
}
// Check that the password matches the original
if expectedPassword != string(obj.Data) {
t.Errorf("Loaded password does not match original."+
"\nexpected: %q\nreceived: %q", expectedPassword, obj.Data)
}
}
// Tests that loadPassword restores the original password saved to stage and
// compares it to the original.
func Test_loadPassword(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
expectedPassword := "MySuperSecurePassword"
// Save the password
err := kv.Set(passwordStorageKey, passwordStorageVersion, &versioned.Object{
Version: passwordStorageVersion,
Timestamp: netTime.Now(),
Data: []byte(expectedPassword),
})
if err != nil {
t.Errorf("Failed to save password to storage: %+v", err)
}
// Attempt to load the password
loadedPassword, err := loadPassword(kv)
if err != nil {
t.Errorf("loadPassword returned an error: %+v", err)
}
// Check that the password matches the original
if expectedPassword != loadedPassword {
t.Errorf("Loaded password does not match original."+
"\nexpected: %q\nreceived: %q", expectedPassword, loadedPassword)
}
}
// Tests that deletePassword deletes the password from storage by trying to recover a
// deleted password.
func Test_deletePassword(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
expectedPassword := "MySuperSecurePassword"
// Save the password
err := savePassword(expectedPassword, kv)
if err != nil {
t.Errorf("Failed to save password to storage: %+v", err)
}
// Delete the password
err = deletePassword(kv)
if err != nil {
t.Errorf("deletePassword returned an error: %+v", err)
}
// Attempt to load the password
obj, err := loadPassword(kv)
if err == nil || obj != "" {
t.Errorf("Loaded object from storage when it should be deleted: %+v", obj)
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment