Skip to content
Snippets Groups Projects
Select Git revision
  • e8563e2937e8807c416292c9daa15c36a4eb8992
  • release default protected
  • 11-22-implement-kv-interface-defined-in-collectiveversionedkvgo
  • hotfix/TestHostPool_UpdateNdf_AddFilter
  • XX-4719/announcementChannels
  • xx-4717/logLevel
  • jonah/noob-channel
  • master protected
  • XX-4707/tagDiskJson
  • xx-4698/notification-retry
  • hotfix/notifylockup
  • syncNodes
  • hotfix/localCB
  • XX-4677/NewChanManagerMobile
  • XX-4689/DmSync
  • duplicatePrefix
  • XX-4601/HavenInvites
  • finalizedUICallbacks
  • XX-4673/AdminKeySync
  • debugNotifID
  • anne/test
  • v4.7.5
  • v4.7.4
  • v4.7.3
  • v4.7.2
  • v4.7.1
  • v4.6.3
  • v4.6.1
  • v4.5.0
  • v4.4.4
  • v4.3.11
  • v4.3.8
  • v4.3.7
  • v4.3.6
  • v4.3.5
  • v4.2.0
  • v4.3.0
  • v4.3.4
  • v4.3.3
  • v4.3.2
  • v4.3.1
41 results

firstMessagePart.go

Blame
  • keyStorage.go 3.50 KiB
    ////////////////////////////////////////////////////////////////////////////////
    // 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 (
    	"bytes"
    	"github.com/pkg/errors"
    	"gitlab.com/elixxir/client/storage/versioned"
    	"gitlab.com/elixxir/crypto/backup"
    	"gitlab.com/xx_network/primitives/netTime"
    )
    
    const (
    	passwordStorageVersion = 0
    	passwordStorageKey     = "BackupPassword"
    	cryptoStorageVersion   = 0
    	cryptoStorageKey       = "BackupCryptoInfo"
    )
    
    // Length of marshalled fields.
    const (
    	keyLen    = backup.KeyLen
    	saltLen   = backup.SaltLen
    	paramsLen = backup.ParamsLen
    )
    
    // saveBackup saves the key, salt, and params to storage.
    func saveBackup(key, salt []byte, params backup.Params, kv *versioned.KV) error {
    
    	obj := &versioned.Object{
    		Version:   cryptoStorageVersion,
    		Timestamp: netTime.Now(),
    		Data:      marshalBackup(key, salt, params),
    	}
    
    	return kv.Set(cryptoStorageKey, cryptoStorageVersion, obj)
    }
    
    // loadBackup loads the key, salt, and params from storage.
    func loadBackup(kv *versioned.KV) (key, salt []byte, params backup.Params, err error) {
    	obj, err := kv.Get(cryptoStorageKey, cryptoStorageVersion)
    	if err != nil {
    		return
    	}
    
    	return unmarshalBackup(obj.Data)
    }
    
    // deleteBackup deletes the key, salt, and params from storage.
    func deleteBackup(kv *versioned.KV) error {
    	return kv.Delete(cryptoStorageKey, cryptoStorageVersion)
    }
    
    // marshalBackup marshals the backup's key, salt, and params into a byte slice.
    func marshalBackup(key, salt []byte, params backup.Params) []byte {
    	buff := bytes.NewBuffer(nil)
    	buff.Grow(keyLen + saltLen + paramsLen)
    
    	// Write key to buffer
    	buff.Write(key)
    
    	// Write salt to buffer
    	buff.Write(salt)
    
    	// Write marshalled params to buffer
    	buff.Write(params.Marshal())
    
    	return buff.Bytes()
    }
    
    // unmarshalBackup unmarshalls the byte slice into a key, salt, and params.
    func unmarshalBackup(buf []byte) (key, salt []byte, params backup.Params, err error) {
    	buff := bytes.NewBuffer(buf)
    	// get key
    	key = make([]byte, keyLen)
    	n, err := buff.Read(key)
    	if err != nil || n != keyLen {
    		err = errors.Errorf("reading key failed: %+v", err)
    		return
    	}
    
    	// get salt
    	salt = make([]byte, saltLen)
    	n, err = buff.Read(salt)
    	if err != nil || n != saltLen {
    		err = errors.Errorf("reading salt failed: %+v", err)
    		return
    	}
    
    	// get params from remaining bytes
    	err = params.Unmarshal(buff.Bytes())
    	if err != nil {
    		err = errors.Errorf("reading params failed: %+v", err)
    	}
    
    	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)
    }