prologic-saltyim/identity.go

package saltyim

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"

	"github.com/keys-pub/keys"
	"go.mills.io/salty"
)

var (
	defaultConfigPaths = []string{
		"$HOME/.config/salty/",
		"$HOME/.salty/",
	}

	defaultIdentityPaths = []string{
		"$HOME/.config/salty/$USER.key",
		"$HOME/.salty/$USER.key",
	}
)

func readUser(fd io.Reader) (Addr, error) {
	scan := bufio.NewScanner(fd)

	var a Addr
	for scan.Scan() {
		if strings.HasPrefix(scan.Text(), "# user:") {
			user := strings.Split(strings.TrimSpace(strings.TrimPrefix(scan.Text(), "# user:")), "@")
			if len(user) != 2 {
				return Addr{}, fmt.Errorf("user not found")
			}
			a.User, a.Domain = user[0], user[1]
		}
	}
	return a, scan.Err()
}

// GetConfigDir returns a suitable configuration directory
func GetConfigDir() string {
	if configDir := os.Getenv("XDG_CONFIG_HOME"); configDir != "" {
		return filepath.Join(configDir, "salty")
	}
	for _, p := range defaultConfigPaths {
		if p := os.ExpandEnv(p); DirExists(p) || DirExists(filepath.Join(p, "..")) {
			return p
		}
	}
	return ""
}

// DefaultIdentity returns a default identity file (if one exists) otherwise
// returns an empty string
func DefaultIdentity() string {
	for _, p := range defaultIdentityPaths {
		if fn := os.ExpandEnv(p); FileExists(fn) {
			return fn
		}
	}
	return ""
}

// CreateIdentity ...
func CreateIdentity(fn, user string) error {
	f, err := os.OpenFile(fn, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
	if err != nil {
		return fmt.Errorf("error opening identity %s for writing: %w", fn, err)
	}
	defer f.Close()

	salty.GenerateKeys(f)

	f.Write([]byte(fmt.Sprintf("# user: %s\n", user)))

	if err := f.Sync(); err != nil {
		return fmt.Errorf("error syncing identity %s for writing: %w", fn, err)
	}

	if err := f.Close(); err != nil {
		return fmt.Errorf("error closing identity %s for writing: %w", fn, err)
	}

	return nil
}

// GetIdentity ...
func GetIdentity(fn string) (*keys.EdX25519Key, Addr, error) {
	id, err := os.Open(fn)
	if err != nil {
		return nil, Addr{}, fmt.Errorf("error opening identity file: %q", fn)
	}
	defer id.Close()

	key, err := salty.ParseIdentity(id)
	if err != nil {
		return nil, Addr{}, fmt.Errorf("error reading private key: %q", fn)
	}

	id.Seek(0, 0)
	me, err := readUser(id)
	if err != nil {
		return key, Addr{}, fmt.Errorf("error reading user from keyfile: %q", fn)
	}

	return key, me, nil
}