Add missing and ignored files

.gitignore

@@ -1,8 +1,7 @@
 cpu.out
 vendor
-cmd/cmd*
 cmd/jess*
 dist
 
-# Custom dev deops
+# Custom dev deps
 go.mod.*

cmd/cmd-import-export.go

@@ -0,0 +1,170 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/safing/jess"
+)
+
+func init() {
+	rootCmd.AddCommand(exportCmd)
+	rootCmd.AddCommand(backupCmd)
+	rootCmd.AddCommand(importCmd)
+}
+
+var (
+	exportCmdHelp = "usage: export <id>"
+	exportCmd     = &cobra.Command{
+		Use:   "export <id>",
+		Short: "export a signet or envelope",
+		Long:  "export a signet (as a recipient - the public key only) or an envelope (configuration)",
+		RunE:  handleExport,
+	}
+
+	backupCmdHelp = "usage: backup <id"
+	backupCmd     = &cobra.Command{
+		Use:   "backup <id>",
+		Short: "backup a signet",
+		Long:  "backup a signet (the private key - do not share!)",
+		RunE:  handleBackup,
+	}
+
+	importCmdHelp = "usage: import <text>"
+	importCmd     = &cobra.Command{
+		Use:   "import <text>",
+		Short: "import a signet or an enveleope",
+		Long:  "import a signet (any kind) or an enveleope",
+		RunE:  handleImport,
+	}
+)
+
+func handleExport(cmd *cobra.Command, args []string) error {
+	// Check args.
+	if len(args) != 1 {
+		return errors.New(exportCmdHelp)
+	}
+	id := args[0]
+
+	// Get Recipient.
+	recipient, err := trustStore.GetSignet(id, true)
+	if err == nil {
+		text, err := recipient.Export(false)
+		if err != nil {
+			return fmt.Errorf("failed to export recipient %s: %w", id, err)
+		}
+		fmt.Println(text)
+		return nil
+	}
+
+	// Check if there is a signet instead.
+	signet, err := trustStore.GetSignet(id, false)
+	if err == nil {
+		recipient, err := signet.AsRecipient()
+		if err != nil {
+			return fmt.Errorf("failed convert signet %s to recipient for export: %w", id, err)
+		}
+		text, err := recipient.Export(false)
+		if err != nil {
+			return fmt.Errorf("failed to export recipient %s: %w", id, err)
+		}
+		fmt.Println(text)
+		return nil
+	}
+
+	// Check for an envelope.
+	env, err := trustStore.GetEnvelope(id)
+	if err == nil {
+		text, err := env.Export(false)
+		if err != nil {
+			return fmt.Errorf("failed to export envelope %s: %w", id, err)
+		}
+		fmt.Println(text)
+		return nil
+	}
+
+	return errors.New("no recipient or envelope found with the given ID")
+}
+
+func handleBackup(cmd *cobra.Command, args []string) error {
+	// Check args.
+	if len(args) != 1 {
+		return errors.New(backupCmdHelp)
+	}
+	id := args[0]
+
+	// Check if there is a signet instead.
+	signet, err := trustStore.GetSignet(id, false)
+	if err != nil {
+		text, err := signet.Backup(false)
+		if err != nil {
+			return fmt.Errorf("failed to backup signet %s: %w", id, err)
+		}
+		fmt.Println(text)
+		return nil
+	}
+
+	return errors.New("no signet found with the given ID")
+}
+
+func handleImport(cmd *cobra.Command, args []string) error {
+	// Check args.
+	if len(args) != 1 {
+		return errors.New(importCmdHelp)
+	}
+	text := args[0]
+
+	// First, check if it's an envelope.
+	if strings.HasPrefix(text, jess.ExportEnvelopePrefix) {
+		env, err := jess.EnvelopeFromTextFormat(text)
+		if err != nil {
+			return fmt.Errorf("failed to parse envelope: %w", err)
+		}
+		err = trustStore.StoreEnvelope(env)
+		if err != nil {
+			return fmt.Errorf("failed to import envelope into trust store: %w", err)
+		}
+		fmt.Printf("imported envelope %q intro trust store\n", env.Name)
+		return nil
+	}
+
+	// Then handle all signet types together.
+	var (
+		signetType string
+		parseFunc  func(textFormat string) (*jess.Signet, error)
+	)
+	switch {
+	case strings.HasPrefix(text, jess.ExportSenderPrefix):
+		signetType = jess.ExportSenderKeyword
+		parseFunc = jess.SenderFromTextFormat
+	case strings.HasPrefix(text, jess.ExportRecipientPrefix):
+		signetType = jess.ExportRecipientKeyword
+		parseFunc = jess.RecipientFromTextFormat
+	case strings.HasPrefix(text, jess.ExportKeyPrefix):
+		signetType = jess.ExportKeyKeyword
+		parseFunc = jess.KeyFromTextFormat
+	default:
+		return fmt.Errorf(
+			"invalid format or unknown type, expected one of %s, %s, %s, %s",
+			jess.ExportKeyKeyword,
+			jess.ExportSenderKeyword,
+			jess.ExportRecipientKeyword,
+			jess.ExportEnvelopeKeyword,
+		)
+	}
+	// Parse and import
+	signet, err := parseFunc(text)
+	if err != nil {
+		return fmt.Errorf("failed to parse %s: %w", signetType, err)
+	}
+	err = trustStore.StoreSignet(signet)
+	if err != nil {
+		return fmt.Errorf("failed to import %s into trust store: %w", signetType, err)
+	}
+	fmt.Printf("imported %s %s intro trust store\n", signetType, signet.ID)
+
+	return nil
+}

cmd/cmd-sign.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/safing/jess/filesig"
+)
+
+func init() {
+	rootCmd.AddCommand(signCmd)
+	signCmd.Flags().StringVarP(&closeFlagOutput, "output", "o", "", "specify output file (`-` for stdout")
+	signCmd.Flags().StringToStringVarP(&metaDataFlag, "metadata", "m", nil, "specify file metadata to sign")
+}
+
+var (
+	metaDataFlag map[string]string
+	signCmdHelp  = "usage: jess sign <file> with <envelope name>"
+
+	signCmd = &cobra.Command{
+		Use:                   "sign <file> with <envelope name>",
+		Short:                 "sign file",
+		Long:                  "sign file with the given envelope. Use `-` to use stdin",
+		DisableFlagsInUseLine: true,
+		PreRunE:               requireTrustStore,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			registerPasswordCallbacks()
+
+			// check args
+			if len(args) != 3 || args[1] != "with" {
+				return errors.New(signCmdHelp)
+			}
+
+			// get envelope
+			envelope, err := trustStore.GetEnvelope(args[2])
+			if err != nil {
+				return err
+			}
+
+			// check filenames
+			filename := args[0]
+			outputFilename := closeFlagOutput
+			if outputFilename == "" {
+				if strings.HasSuffix(filename, filesig.Extension) {
+					return errors.New("cannot automatically derive output filename, please specify with --output")
+				}
+				outputFilename = filename + filesig.Extension
+			}
+
+			fd, err := filesig.SignFile(filename, outputFilename, metaDataFlag, envelope, trustStore)
+			if err != nil {
+				return err
+			}
+
+			fmt.Print(formatSignatures(filename, outputFilename, []*filesig.FileData{fd}))
+			return nil
+		},
+	}
+)