rename to credentials

cmd/enpasscli/main.go

@@ -191,25 +191,25 @@ func entryPassword(logger *logrus.Logger, vault *enpass.Vault, args *Args) {
 	}
 }
 
-func assembleVaultAccessData(logger *logrus.Logger, args *Args, store *unlock.SecureStore) *enpass.VaultAccessData {
-	accessData := &enpass.VaultAccessData{
+func assembleVaultCredentials(logger *logrus.Logger, args *Args, store *unlock.SecureStore) *enpass.VaultCredentials {
+	credentials := &enpass.VaultCredentials{
 		Password:    os.Getenv("MASTERPW"),
 		KeyfilePath: *args.keyFilePath,
 	}
 
-	if !accessData.IsComplete() && store != nil {
+	if !credentials.IsComplete() && store != nil {
 		var err error
-		if accessData.DBKey, err = store.Read(); err != nil {
-			logger.WithError(err).Fatal("could not read access data from store")
+		if credentials.DBKey, err = store.Read(); err != nil {
+			logger.WithError(err).Fatal("could not read credentials from store")
 		}
-		logger.Debug("read access data from store")
+		logger.Debug("read credentials from store")
 	}
 
-	if !accessData.IsComplete() {
-		accessData.Password = prompt(logger, args, "master password")
+	if !credentials.IsComplete() {
+		credentials.Password = prompt(logger, args, "master password")
 	}
 
-	return accessData
+	return credentials
 }
 
 func initializeStore(logger *logrus.Logger, args *Args) *unlock.SecureStore {
@@ -283,12 +283,12 @@ func main() {
 		logger.Debug("initialized store")
 	}
 
-	accessData := assembleVaultAccessData(logger, args, store)
+	credentials := assembleVaultCredentials(logger, args, store)
 
 	defer func() {
 		vault.Close()
 	}()
-	if err := vault.Open(accessData); err != nil {
+	if err := vault.Open(credentials); err != nil {
 		logger.WithError(err).Error("could not open vault")
 		logger.Exit(2)
 	}
@@ -310,8 +310,8 @@ func main() {
 	}
 
 	if store != nil {
-		if err := store.Write(accessData.DBKey); err != nil {
-			logger.WithError(err).Fatal("failed to write access data to store")
+		if err := store.Write(credentials.DBKey); err != nil {
+			logger.WithError(err).Fatal("failed to write credentials to store")
 		}
 	}
 }

pkg/enpass/vault.go

@@ -42,14 +42,14 @@ type Vault struct {
 	vaultInfo VaultInfo
 }
 
-type VaultAccessData struct {
+type VaultCredentials struct {
 	KeyfilePath string
 	Password    string
 	DBKey       []byte
 }
 
-func (accessData *VaultAccessData) IsComplete() bool {
-	return accessData.Password != "" || accessData.DBKey != nil
+func (credentials *VaultCredentials) IsComplete() bool {
+	return credentials.Password != "" || credentials.DBKey != nil
 }
 
 // NewVault : Create new instance of vault and load vault info
@@ -113,24 +113,24 @@ func (v *Vault) checkPaths() error {
 	return nil
 }
 
-func (v *Vault) generateAndSetDBKey(accessData *VaultAccessData) error {
-	if accessData.DBKey != nil {
+func (v *Vault) generateAndSetDBKey(credentials *VaultCredentials) error {
+	if credentials.DBKey != nil {
 		v.logger.Debug("skipping database key generation, already set")
 		return nil
 	}
 
-	if accessData.Password == "" {
+	if credentials.Password == "" {
 		return errors.New("empty vault password provided")
 	}
 
-	if accessData.KeyfilePath == "" && v.vaultInfo.HasKeyfile == 1 {
+	if credentials.KeyfilePath == "" && v.vaultInfo.HasKeyfile == 1 {
 		return errors.New("you should specify a keyfile")
-	} else if accessData.KeyfilePath != "" && v.vaultInfo.HasKeyfile == 0 {
+	} else if credentials.KeyfilePath != "" && v.vaultInfo.HasKeyfile == 0 {
 		return errors.New("you are specifying an unnecessary keyfile")
 	}
 
 	v.logger.Debug("generating master password")
-	masterPassword, err := v.generateMasterPassword([]byte(accessData.Password), accessData.KeyfilePath)
+	masterPassword, err := v.generateMasterPassword([]byte(credentials.Password), credentials.KeyfilePath)
 	if err != nil {
 		return errors.Wrap(err, "could not generate vault unlock key")
 	}
@@ -142,7 +142,7 @@ func (v *Vault) generateAndSetDBKey(accessData *VaultAccessData) error {
 	}
 
 	v.logger.Debug("deriving decryption key")
-	accessData.DBKey, err = v.deriveKey(masterPassword, keySalt)
+	credentials.DBKey, err = v.deriveKey(masterPassword, keySalt)
 	if err != nil {
 		return errors.Wrap(err, "could not derive database key from master password")
 	}
@@ -151,14 +151,14 @@ func (v *Vault) generateAndSetDBKey(accessData *VaultAccessData) error {
 }
 
 // Open : setup a connection to the Enpass database. Call this before doing anything.
-func (v *Vault) Open(accessData *VaultAccessData) error {
+func (v *Vault) Open(credentials *VaultCredentials) error {
 	v.logger.Debug("generating database key")
-	if err := v.generateAndSetDBKey(accessData); err != nil {
+	if err := v.generateAndSetDBKey(credentials); err != nil {
 		return errors.Wrap(err, "could not generate database key")
 	}
 
 	v.logger.Debug("opening encrypted database")
-	if err := v.openEncryptedDatabase(v.databaseFilename, accessData.DBKey); err != nil {
+	if err := v.openEncryptedDatabase(v.databaseFilename, credentials.DBKey); err != nil {
 		return errors.Wrap(err, "could not open encrypted database")
 	}
 

pkg/enpass/vault_test.go

@@ -17,8 +17,8 @@ func TestVault_Initialize(t *testing.T) {
 		t.Errorf("vault initialization failed: %+v", err)
 	}
 	defer vault.Close()
-	accessData := &VaultAccessData{Password: testPassword}
-	if err := vault.Open(accessData); err != nil {
+	credentials := &VaultCredentials{Password: testPassword}
+	if err := vault.Open(credentials); err != nil {
 		t.Errorf("opening vault failed: %+v", err)
 	}
 }
@@ -29,8 +29,8 @@ func TestVault_GetEntries(t *testing.T) {
 		t.Errorf("vault initialization failed: %+v", err)
 	}
 	defer vault.Close()
-	accessData := &VaultAccessData{Password: testPassword}
-	if err := vault.Open(accessData); err != nil {
+	credentials := &VaultCredentials{Password: testPassword}
+	if err := vault.Open(credentials); err != nil {
 		t.Errorf("opening vault failed: %+v", err)
 	}