128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
package cmd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/icza/gox/stringsx"
|
|
"github.com/quexten/goldwarden/cli/client"
|
|
"github.com/quexten/goldwarden/cli/ipc/messages"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
var baseLoginCmd = &cobra.Command{
|
|
Use: "logins",
|
|
Short: "Commands for managing logins.",
|
|
Long: `Commands for managing logins.`,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
_ = cmd.Help()
|
|
},
|
|
}
|
|
|
|
var getLoginCmd = &cobra.Command{
|
|
Use: "get",
|
|
Short: "Gets a login in your vault",
|
|
Long: `Gets a login in your vault.`,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
err := loginIfRequired()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
uuid, _ := cmd.Flags().GetString("uuid")
|
|
name, _ := cmd.Flags().GetString("name")
|
|
username, _ := cmd.Flags().GetString("username")
|
|
fullOutput, _ := cmd.Flags().GetBool("full")
|
|
|
|
resp, err := commandClient.SendToAgent(messages.GetLoginRequest{
|
|
Name: name,
|
|
Username: username,
|
|
UUID: uuid,
|
|
})
|
|
if err != nil {
|
|
handleSendToAgentError(err)
|
|
return
|
|
}
|
|
|
|
switch resp.(type) {
|
|
case messages.GetLoginResponse:
|
|
response := resp.(messages.GetLoginResponse)
|
|
if fullOutput {
|
|
fmt.Println(response.Result)
|
|
} else {
|
|
fmt.Println(response.Result.Password)
|
|
}
|
|
return
|
|
case messages.ActionResponse:
|
|
fmt.Println("Error: " + resp.(messages.ActionResponse).Message)
|
|
return
|
|
}
|
|
},
|
|
}
|
|
|
|
var listLoginsCmd = &cobra.Command{
|
|
Use: "list",
|
|
Short: "Lists all logins in your vault",
|
|
Long: `Lists all logins in your vault.`,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
err := loginIfRequired()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
logins, err := ListLogins(commandClient)
|
|
if err != nil {
|
|
handleSendToAgentError(err)
|
|
return
|
|
}
|
|
|
|
var toPrintLogins []map[string]string
|
|
for _, login := range logins {
|
|
data := map[string]string{
|
|
"name": stringsx.Clean(login.Name),
|
|
"uuid": stringsx.Clean(login.UUID),
|
|
"username": stringsx.Clean(login.Username),
|
|
"password": stringsx.Clean(strings.ReplaceAll(login.Password, "\"", "\\\"")),
|
|
"totp": stringsx.Clean(login.TOTPSeed),
|
|
"uri": stringsx.Clean(login.URI),
|
|
}
|
|
toPrintLogins = append(toPrintLogins, data)
|
|
}
|
|
toPrintJSON, _ := json.Marshal(toPrintLogins)
|
|
fmt.Println(string(toPrintJSON))
|
|
},
|
|
}
|
|
|
|
func ListLogins(client client.UnixSocketClient) ([]messages.DecryptedLoginCipher, error) {
|
|
resp, err := client.SendToAgent(messages.ListLoginsRequest{})
|
|
if err != nil {
|
|
return []messages.DecryptedLoginCipher{}, err
|
|
}
|
|
|
|
switch resp.(type) {
|
|
case messages.GetLoginsResponse:
|
|
castedResponse := (resp.(messages.GetLoginsResponse))
|
|
return castedResponse.Result, nil
|
|
case messages.ActionResponse:
|
|
castedResponse := (resp.(messages.ActionResponse))
|
|
return []messages.DecryptedLoginCipher{}, errors.New("Error: " + castedResponse.Message)
|
|
default:
|
|
return []messages.DecryptedLoginCipher{}, errors.New("Wrong response type")
|
|
}
|
|
}
|
|
|
|
func init() {
|
|
rootCmd.AddCommand(baseLoginCmd)
|
|
baseLoginCmd.AddCommand(getLoginCmd)
|
|
getLoginCmd.PersistentFlags().String("name", "", "")
|
|
getLoginCmd.PersistentFlags().String("username", "", "")
|
|
getLoginCmd.PersistentFlags().String("uuid", "", "")
|
|
getLoginCmd.PersistentFlags().Bool("full", false, "")
|
|
baseLoginCmd.AddCommand(listLoginsCmd)
|
|
}
|