create DB struct

This is step one in detaching the Database layer from Headscale (h). The
ultimate goal is to have all function that does database operations in
its own package, and keep the business logic and writing separate.

Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com>

hscontrol/util/addr.go

@@ -0,0 +1,42 @@
+package util
+
+import (
+	"net/netip"
+	"reflect"
+
+	"go4.org/netipx"
+)
+
+func GetIPPrefixEndpoints(na netip.Prefix) (netip.Addr, netip.Addr) {
+	var network, broadcast netip.Addr
+	ipRange := netipx.RangeOfPrefix(na)
+	network = ipRange.From()
+	broadcast = ipRange.To()
+
+	return network, broadcast
+}
+
+func StringToIPPrefix(prefixes []string) ([]netip.Prefix, error) {
+	result := make([]netip.Prefix, len(prefixes))
+
+	for index, prefixStr := range prefixes {
+		prefix, err := netip.ParsePrefix(prefixStr)
+		if err != nil {
+			return []netip.Prefix{}, err
+		}
+
+		result[index] = prefix
+	}
+
+	return result, nil
+}
+
+func StringOrPrefixListContains[T string | netip.Prefix](ts []T, t T) bool {
+	for _, v := range ts {
+		if reflect.DeepEqual(v, t) {
+			return true
+		}
+	}
+
+	return false
+}

hscontrol/util/file.go

@@ -0,0 +1,43 @@
+package util
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/viper"
+)
+
+const (
+	Base8     = 8
+	Base10    = 10
+	BitSize16 = 16
+	BitSize32 = 32
+	BitSize64 = 64
+)
+
+func AbsolutePathFromConfigPath(path string) string {
+	// If a relative path is provided, prefix it with the directory where
+	// the config file was found.
+	if (path != "") && !strings.HasPrefix(path, string(os.PathSeparator)) {
+		dir, _ := filepath.Split(viper.ConfigFileUsed())
+		if dir != "" {
+			path = filepath.Join(dir, path)
+		}
+	}
+
+	return path
+}
+
+func GetFileMode(key string) fs.FileMode {
+	modeStr := viper.GetString(key)
+
+	mode, err := strconv.ParseUint(modeStr, Base8, BitSize64)
+	if err != nil {
+		return PermissionFallback
+	}
+
+	return fs.FileMode(mode)
+}

hscontrol/util/key.go

@@ -0,0 +1,117 @@
+package util
+
+import (
+	"encoding/json"
+	"errors"
+	"regexp"
+	"strings"
+
+	"tailscale.com/types/key"
+)
+
+const (
+
+	// These constants are copied from the upstream tailscale.com/types/key
+	// library, because they are not exported.
+	// https://github.com/tailscale/tailscale/tree/main/types/key
+
+	// nodePublicHexPrefix is the prefix used to identify a
+	// hex-encoded node public key.
+	//
+	// This prefix is used in the control protocol, so cannot be
+	// changed.
+	nodePublicHexPrefix = "nodekey:"
+
+	// machinePublicHexPrefix is the prefix used to identify a
+	// hex-encoded machine public key.
+	//
+	// This prefix is used in the control protocol, so cannot be
+	// changed.
+	machinePublicHexPrefix = "mkey:"
+
+	// discoPublicHexPrefix is the prefix used to identify a
+	// hex-encoded disco public key.
+	//
+	// This prefix is used in the control protocol, so cannot be
+	// changed.
+	discoPublicHexPrefix = "discokey:"
+
+	// privateKey prefix.
+	privateHexPrefix = "privkey:"
+
+	PermissionFallback = 0o700
+
+	ZstdCompression = "zstd"
+)
+
+var (
+	NodePublicKeyRegex       = regexp.MustCompile("nodekey:[a-fA-F0-9]+")
+	ErrCannotDecryptResponse = errors.New("cannot decrypt response")
+)
+
+func MachinePublicKeyStripPrefix(machineKey key.MachinePublic) string {
+	return strings.TrimPrefix(machineKey.String(), machinePublicHexPrefix)
+}
+
+func NodePublicKeyStripPrefix(nodeKey key.NodePublic) string {
+	return strings.TrimPrefix(nodeKey.String(), nodePublicHexPrefix)
+}
+
+func DiscoPublicKeyStripPrefix(discoKey key.DiscoPublic) string {
+	return strings.TrimPrefix(discoKey.String(), discoPublicHexPrefix)
+}
+
+func MachinePublicKeyEnsurePrefix(machineKey string) string {
+	if !strings.HasPrefix(machineKey, machinePublicHexPrefix) {
+		return machinePublicHexPrefix + machineKey
+	}
+
+	return machineKey
+}
+
+func NodePublicKeyEnsurePrefix(nodeKey string) string {
+	if !strings.HasPrefix(nodeKey, nodePublicHexPrefix) {
+		return nodePublicHexPrefix + nodeKey
+	}
+
+	return nodeKey
+}
+
+func DiscoPublicKeyEnsurePrefix(discoKey string) string {
+	if !strings.HasPrefix(discoKey, discoPublicHexPrefix) {
+		return discoPublicHexPrefix + discoKey
+	}
+
+	return discoKey
+}
+
+func PrivateKeyEnsurePrefix(privateKey string) string {
+	if !strings.HasPrefix(privateKey, privateHexPrefix) {
+		return privateHexPrefix + privateKey
+	}
+
+	return privateKey
+}
+
+func DecodeAndUnmarshalNaCl(
+	msg []byte,
+	output interface{},
+	pubKey *key.MachinePublic,
+	privKey *key.MachinePrivate,
+) error {
+	// log.Trace().
+	// 	Str("pubkey", pubKey.ShortString()).
+	// 	Int("length", len(msg)).
+	// 	Msg("Trying to decrypt")
+
+	decrypted, ok := privKey.OpenFrom(*pubKey, msg)
+	if !ok {
+		return ErrCannotDecryptResponse
+	}
+
+	if err := json.Unmarshal(decrypted, output); err != nil {
+		return err
+	}
+
+	return nil
+}

hscontrol/util/net.go

@@ -0,0 +1,12 @@
+package util
+
+import (
+	"context"
+	"net"
+)
+
+func GrpcSocketDialer(ctx context.Context, addr string) (net.Conn, error) {
+	var d net.Dialer
+
+	return d.DialContext(ctx, "unix", addr)
+}

hscontrol/util/string.go

@@ -0,0 +1,85 @@
+package util
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"strings"
+
+	"tailscale.com/tailcfg"
+)
+
+// GenerateRandomBytes returns securely generated random bytes.
+// It will return an error if the system's secure random
+// number generator fails to function correctly, in which
+// case the caller should not continue.
+func GenerateRandomBytes(n int) ([]byte, error) {
+	bytes := make([]byte, n)
+
+	// Note that err == nil only if we read len(b) bytes.
+	if _, err := rand.Read(bytes); err != nil {
+		return nil, err
+	}
+
+	return bytes, nil
+}
+
+// GenerateRandomStringURLSafe returns a URL-safe, base64 encoded
+// securely generated random string.
+// It will return an error if the system's secure random
+// number generator fails to function correctly, in which
+// case the caller should not continue.
+func GenerateRandomStringURLSafe(n int) (string, error) {
+	b, err := GenerateRandomBytes(n)
+
+	return base64.RawURLEncoding.EncodeToString(b), err
+}
+
+// GenerateRandomStringDNSSafe returns a DNS-safe
+// securely generated random string.
+// It will return an error if the system's secure random
+// number generator fails to function correctly, in which
+// case the caller should not continue.
+func GenerateRandomStringDNSSafe(size int) (string, error) {
+	var str string
+	var err error
+	for len(str) < size {
+		str, err = GenerateRandomStringURLSafe(size)
+		if err != nil {
+			return "", err
+		}
+		str = strings.ToLower(
+			strings.ReplaceAll(strings.ReplaceAll(str, "_", ""), "-", ""),
+		)
+	}
+
+	return str[:size], nil
+}
+
+func IsStringInSlice(slice []string, str string) bool {
+	for _, s := range slice {
+		if s == str {
+			return true
+		}
+	}
+
+	return false
+}
+
+func TailNodesToString(nodes []*tailcfg.Node) string {
+	temp := make([]string, len(nodes))
+
+	for index, node := range nodes {
+		temp[index] = node.Name
+	}
+
+	return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
+}
+
+func TailMapResponseToString(resp tailcfg.MapResponse) string {
+	return fmt.Sprintf(
+		"{ Node: %s, Peers: %s }",
+		resp.Node.Name,
+		TailNodesToString(resp.Peers),
+	)
+}

hscontrol/util/string_test.go

@@ -0,0 +1,15 @@
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGenerateRandomStringDNSSafe(t *testing.T) {
+	for i := 0; i < 100000; i++ {
+		str, err := GenerateRandomStringDNSSafe(8)
+		assert.Nil(t, err)
+		assert.Len(t, str, 8)
+	}
+}