Revert "keyring swap, better error messages/warnings, delay upgrade notif"

This reverts commit 7f69a3b23f.

cli/packages/cmd/export.go

@@ -77,7 +77,7 @@ var exportCmd = &cobra.Command{
 
 		secrets, err := util.GetAllEnvironmentVariables(models.GetAllSecretsParameters{Environment: environmentName, InfisicalToken: infisicalToken, TagSlugs: tagSlugs, WorkspaceId: projectId, SecretsPath: secretsPath})
 		if err != nil {
-			util.HandleError(err, "Something went wrong when fetching secrets for export")
+			util.HandleError(err, "Unable to fetch secrets")
 		}
 
 		if secretOverriding {
@@ -112,7 +112,7 @@ func init() {
 	exportCmd.Flags().Bool("expand", true, "Parse shell parameter expansions in your secrets")
 	exportCmd.Flags().StringP("format", "f", "dotenv", "Set the format of the output file (dotenv, json, csv)")
 	exportCmd.Flags().Bool("secret-overriding", true, "Prioritizes personal secrets, if any, with the same name over shared secrets")
-	exportCmd.Flags().String("token", "", "Fetch secrets using the service token [can also set via environment variable name: INFISICAL_TOKEN")
+	exportCmd.Flags().String("token", "", "Fetch secrets using the Infisical Token")
 	exportCmd.Flags().StringP("tags", "t", "", "filter secrets by tag slugs")
 	exportCmd.Flags().String("projectId", "", "manually set the projectId to fetch secrets from")
 	exportCmd.Flags().String("path", "/", "get secrets within a folder path")

cli/packages/cmd/init.go

@@ -46,10 +46,6 @@ var initCmd = &cobra.Command{
 			util.HandleError(err, "Unable to get your login details")
 		}
 
-		if userCreds.LoginExpired {
-			util.PrintErrorMessageAndExit("Your login session has expired, please run [infisical login] and try again")
-		}
-
 		httpClient := resty.New()
 		httpClient.SetAuthToken(userCreds.UserCredentials.JTWToken)
 		workspaceResponse, err := api.CallGetAllWorkSpacesUserBelongsTo(httpClient)

cli/packages/cmd/login.go

@@ -117,7 +117,8 @@ var loginCmd = &cobra.Command{
 
 		err = util.StoreUserCredsInKeyRing(&userCredentialsToBeStored)
 		if err != nil {
-			log.Error().Msg("Unable to store your credentials in keyring")
+			currentVault, _ := util.GetCurrentVaultBackend()
+			log.Error().Msgf("Unable to store your credentials in system vault [%s]. Rerun with flag -d to see full logs", currentVault)
 			log.Error().Msgf("\nTo trouble shoot further, read https://infisical.com/docs/cli/faq")
 			log.Debug().Err(err)
 			//return here

cli/packages/cmd/reset.go

@@ -26,8 +26,13 @@ var resetCmd = &cobra.Command{
 
 		os.RemoveAll(pathToDir)
 
-		// TODO
-		// keyring.Delete()
+		// delete keyring
+		keyringInstance, err := util.GetKeyRing()
+		if err != nil {
+			util.HandleError(err)
+		}
+
+		keyringInstance.Remove(util.KEYRING_SERVICE_NAME)
 
 		// delete secrets backup
 		util.DeleteBackupSecrets()

cli/packages/cmd/run.go

@@ -188,7 +188,7 @@ func filterReservedEnvVars(env map[string]models.SingleEnvironmentVariable) {
 
 func init() {
 	rootCmd.AddCommand(runCmd)
-	runCmd.Flags().String("token", "", "Fetch secrets using the service token [can also set via environment variable name: INFISICAL_TOKEN")
+	runCmd.Flags().String("token", "", "Fetch secrets using the Infisical Token")
 	runCmd.Flags().StringP("env", "e", "dev", "Set the environment (dev, prod, etc.) from which your secrets should be pulled from")
 	runCmd.Flags().Bool("expand", true, "Parse shell parameter expansions in your secrets")
 	runCmd.Flags().Bool("include-imports", true, "Import linked secrets ")

cli/packages/cmd/secrets.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 	"unicode"
 
+	"crypto/sha256"
+
 	"github.com/Infisical/infisical-merge/packages/api"
 	"github.com/Infisical/infisical-merge/packages/crypto"
 	"github.com/Infisical/infisical-merge/packages/models"
@@ -126,10 +128,6 @@ var secretsSetCmd = &cobra.Command{
 			util.HandleError(err, "Unable to authenticate")
 		}
 
-		if loggedInUserDetails.LoginExpired {
-			util.PrintErrorMessageAndExit("Your login session has expired, please run [infisical login] and try again")
-		}
-
 		httpClient := resty.New().
 			SetAuthToken(loggedInUserDetails.UserCredentials.JTWToken).
 			SetHeader("Accept", "application/json")
@@ -188,11 +186,13 @@ var secretsSetCmd = &cobra.Command{
 			key := strings.ToUpper(splitKeyValueFromArg[0])
 			value := splitKeyValueFromArg[1]
 
+			hashedKey := fmt.Sprintf("%x", sha256.Sum256([]byte(key)))
 			encryptedKey, err := crypto.EncryptSymmetric([]byte(key), []byte(plainTextEncryptionKey))
 			if err != nil {
 				util.HandleError(err, "unable to encrypt your secrets")
 			}
 
+			hashedValue := fmt.Sprintf("%x", sha256.Sum256([]byte(value)))
 			encryptedValue, err := crypto.EncryptSymmetric([]byte(value), []byte(plainTextEncryptionKey))
 			if err != nil {
 				util.HandleError(err, "unable to encrypt your secrets")
@@ -205,6 +205,7 @@ var secretsSetCmd = &cobra.Command{
 					SecretValueCiphertext: base64.StdEncoding.EncodeToString(encryptedValue.CipherText),
 					SecretValueIV:         base64.StdEncoding.EncodeToString(encryptedValue.Nonce),
 					SecretValueTag:        base64.StdEncoding.EncodeToString(encryptedValue.AuthTag),
+					SecretValueHash:       hashedValue,
 					PlainTextKey:          key,
 					Type:                  existingSecret.Type,
 				}
@@ -232,9 +233,11 @@ var secretsSetCmd = &cobra.Command{
 					SecretKeyCiphertext:   base64.StdEncoding.EncodeToString(encryptedKey.CipherText),
 					SecretKeyIV:           base64.StdEncoding.EncodeToString(encryptedKey.Nonce),
 					SecretKeyTag:          base64.StdEncoding.EncodeToString(encryptedKey.AuthTag),
+					SecretKeyHash:         hashedKey,
 					SecretValueCiphertext: base64.StdEncoding.EncodeToString(encryptedValue.CipherText),
 					SecretValueIV:         base64.StdEncoding.EncodeToString(encryptedValue.Nonce),
 					SecretValueTag:        base64.StdEncoding.EncodeToString(encryptedValue.AuthTag),
+					SecretValueHash:       hashedValue,
 					Type:                  util.SECRET_TYPE_SHARED,
 					PlainTextKey:          key,
 				}
@@ -331,10 +334,6 @@ var secretsDeleteCmd = &cobra.Command{
 			util.HandleError(err, "Unable to authenticate")
 		}
 
-		if loggedInUserDetails.LoginExpired {
-			util.PrintErrorMessageAndExit("Your login session has expired, please run [infisical login] and try again")
-		}
-
 		workspaceFile, err := util.GetWorkSpaceFromFile()
 		if err != nil {
 			util.HandleError(err, "Unable to get local project details")
@@ -628,10 +627,10 @@ func getSecretsByKeys(secrets []models.SingleEnvironmentVariable) map[string]mod
 
 func init() {
 
-	secretsGenerateExampleEnvCmd.Flags().String("token", "", "Fetch secrets using the service token [can also set via environment variable name: INFISICAL_TOKEN")
+	secretsGenerateExampleEnvCmd.Flags().String("token", "", "Fetch secrets using the Infisical Token")
 	secretsCmd.AddCommand(secretsGenerateExampleEnvCmd)
 
-	secretsGetCmd.Flags().String("token", "", "Fetch secrets using the service token [can also set via environment variable name: INFISICAL_TOKEN")
+	secretsGetCmd.Flags().String("token", "", "Fetch secrets using the Infisical Token")
 	secretsCmd.AddCommand(secretsGetCmd)
 
 	secretsCmd.AddCommand(secretsSetCmd)
@@ -650,7 +649,7 @@ func init() {
 		util.RequireLocalWorkspaceFile()
 	}
 
-	secretsCmd.Flags().String("token", "", "Fetch secrets using the service token [can also set via environment variable name: INFISICAL_TOKEN")
+	secretsCmd.Flags().String("token", "", "Fetch secrets using the Infisical Token")
 	secretsCmd.PersistentFlags().String("env", "dev", "Used to select the environment name on which actions should be taken on")
 	secretsCmd.Flags().Bool("expand", true, "Parse shell parameter expansions in your secrets")
 	secretsCmd.Flags().Bool("include-imports", true, "Imported linked secrets ")

cli/packages/cmd/vault.go

@@ -0,0 +1,103 @@
+/*
+Copyright (c) 2023 Infisical Inc.
+*/
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/99designs/keyring"
+	"github.com/Infisical/infisical-merge/packages/util"
+	"github.com/posthog/posthog-go"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+var vaultSetCmd = &cobra.Command{
+	Example:               `infisical vault set pass`,
+	Use:                   "set [vault-name]",
+	Short:                 "Used to set the vault backend to store your login details securely at rest",
+	DisableFlagsInUseLine: true,
+	Args:                  cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		wantedVaultTypeName := args[0]
+		currentVaultBackend, err := util.GetCurrentVaultBackend()
+		if err != nil {
+			log.Error().Msgf("Unable to set vault to [%s] because of [err=%s]", wantedVaultTypeName, err)
+			return
+		}
+
+		if wantedVaultTypeName == string(currentVaultBackend) {
+			log.Error().Msgf("You are already on vault backend [%s]", currentVaultBackend)
+			return
+		}
+
+		if isVaultToSwitchToValid(wantedVaultTypeName) {
+			configFile, err := util.GetConfigFile()
+			if err != nil {
+				log.Error().Msgf("Unable to set vault to [%s] because of [err=%s]", wantedVaultTypeName, err)
+				return
+			}
+
+			configFile.VaultBackendType = keyring.BackendType(wantedVaultTypeName) // save selected vault
+			configFile.LoggedInUserEmail = ""                                      // reset the logged in user to prompt them to re login
+
+			err = util.WriteConfigFile(&configFile)
+			if err != nil {
+				log.Error().Msgf("Unable to set vault to [%s] because an error occurred when saving the config file [err=%s]", wantedVaultTypeName, err)
+				return
+			}
+
+			fmt.Printf("\nSuccessfully, switched vault backend from [%s] to [%s]. Please login in again to store your login details in the new vault with [infisical login]\n", currentVaultBackend, wantedVaultTypeName)
+
+			Telemetry.CaptureEvent("cli-command:vault set", posthog.NewProperties().Set("currentVault", currentVaultBackend).Set("wantedVault", wantedVaultTypeName).Set("version", util.CLI_VERSION))
+		} else {
+			log.Error().Msgf("The requested vault type [%s] is not available on this system. Only the following vault backends are available for you system: %s", wantedVaultTypeName, keyring.AvailableBackends())
+		}
+	},
+}
+
+// runCmd represents the run command
+var vaultCmd = &cobra.Command{
+	Use:                   "vault",
+	Short:                 "Used to manage where your Infisical login token is saved on your machine",
+	DisableFlagsInUseLine: true,
+	Args:                  cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		printAvailableVaultBackends()
+	},
+}
+
+func printAvailableVaultBackends() {
+	fmt.Printf("The following vaults are available on your system:")
+	for _, backend := range keyring.AvailableBackends() {
+		fmt.Printf("\n- %s", backend)
+	}
+
+	currentVaultBackend, err := util.GetCurrentVaultBackend()
+	if err != nil {
+		log.Error().Msgf("printAvailableVaultBackends: unable to print the available vault backend because of error [err=%s]", err)
+	}
+
+	Telemetry.CaptureEvent("cli-command:vault", posthog.NewProperties().Set("currentVault", currentVaultBackend).Set("version", util.CLI_VERSION))
+
+	fmt.Printf("\n\nYou are currently using [%s] vault to store your login credentials\n", string(currentVaultBackend))
+}
+
+// Checks if the vault that the user wants to switch to is a valid available vault
+func isVaultToSwitchToValid(vaultNameToSwitchTo string) bool {
+	isFound := false
+	for _, backend := range keyring.AvailableBackends() {
+		if vaultNameToSwitchTo == string(backend) {
+			isFound = true
+			break
+		}
+	}
+
+	return isFound
+}
+
+func init() {
+	vaultCmd.AddCommand(vaultSetCmd)
+	rootCmd.AddCommand(vaultCmd)
+}