Factor wgkey to types/key

This commit converts all the uses of wgkey to the new key interfaces.

It now has specific  machine, node and discovery keys and we now should
use them correctly.

Please note the new logic which strips a key prefix (in utils.go) that
is now standard inside tailscale.

In theory we could put it in the database, but to preserve backwards
compatibility and not spend a lot of resources on accounting for both,
we just strip them.

utils.go

@@ -7,50 +7,95 @@ package headscale
 
 import (
 	"context"
-	"crypto/rand"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net"
 	"strings"
 
-	"golang.org/x/crypto/nacl/box"
+	"github.com/rs/zerolog/log"
 	"inet.af/netaddr"
 	"tailscale.com/tailcfg"
-	"tailscale.com/types/wgkey"
+	"tailscale.com/types/key"
 )
 
 const (
 	errCannotDecryptReponse = Error("cannot decrypt response")
 	errResponseMissingNonce = Error("response missing nonce")
 	errCouldNotAllocateIP   = Error("could not find any suitable IP")
+
+	// 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
+
+	// nodePrivateHexPrefix is the prefix used to identify a
+	// hex-encoded node private key.
+	//
+	// This prefix name is a little unfortunate, in that it comes from
+	// WireGuard's own key types, and we've used it for both key types
+	// we persist to disk (machine and node keys). But we're stuck
+	// with it for now, barring another round of tricky migration.
+	nodePrivateHexPrefix = "privkey:"
+
+	// 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:"
+
+	// machinePrivateHexPrefix is the prefix used to identify a
+	// hex-encoded machine private key.
+	//
+	// This prefix name is a little unfortunate, in that it comes from
+	// WireGuard's own key types. Unfortunately we're stuck with it for
+	// machine keys, because we serialize them to disk with this prefix.
+	machinePrivateHexPrefix = "privkey:"
+
+	// 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:"
 )
 
+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)
+}
+
 // Error is used to compare errors as per https://dave.cheney.net/2016/04/07/constant-errors
 type Error string
 
 func (e Error) Error() string { return string(e) }
 
 func decode(
-	msg []byte,
-	v interface{},
-	pubKey *wgkey.Key,
-	privKey *wgkey.Private,
-) error {
-	return decodeMsg(msg, v, pubKey, privKey)
-}
-
-func decodeMsg(
 	msg []byte,
 	output interface{},
-	pubKey *wgkey.Key,
-	privKey *wgkey.Private,
+	pubKey *key.MachinePublic,
+	privKey *key.MachinePrivate,
 ) error {
-	decrypted, err := decryptMsg(msg, pubKey, privKey)
-	if err != nil {
-		return err
+	log.Trace().Int("length", len(msg)).Msg("Trying to decrypt")
+
+	decrypted, ok := privKey.OpenFrom(*pubKey, msg)
+	if !ok {
+		return errCannotDecryptReponse
 	}
-	// fmt.Println(string(decrypted))
+
 	if err := json.Unmarshal(decrypted, output); err != nil {
 		return err
 	}
@@ -58,45 +103,17 @@ func decodeMsg(
 	return nil
 }
 
-func decryptMsg(msg []byte, pubKey *wgkey.Key, privKey *wgkey.Private) ([]byte, error) {
-	var nonce [24]byte
-	if len(msg) < len(nonce)+1 {
-		return nil, errResponseMissingNonce
-	}
-	copy(nonce[:], msg)
-	msg = msg[len(nonce):]
-
-	pub, pri := (*[32]byte)(pubKey), (*[32]byte)(privKey)
-	decrypted, ok := box.Open(nil, msg, &nonce, pub, pri)
-	if !ok {
-		return nil, errCannotDecryptReponse
-	}
-
-	return decrypted, nil
-}
-
-func encode(v interface{}, pubKey *wgkey.Key, privKey *wgkey.Private) ([]byte, error) {
+func encode(
+	v interface{},
+	pubKey *key.MachinePublic,
+	privKey *key.MachinePrivate,
+) ([]byte, error) {
 	b, err := json.Marshal(v)
 	if err != nil {
 		return nil, err
 	}
 
-	return encodeMsg(b, pubKey, privKey)
-}
-
-func encodeMsg(
-	payload []byte,
-	pubKey *wgkey.Key,
-	privKey *wgkey.Private,
-) ([]byte, error) {
-	var nonce [24]byte
-	if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
-		panic(err)
-	}
-	pub, pri := (*[32]byte)(pubKey), (*[32]byte)(privKey)
-	msg := box.Seal(nonce[:], payload, &nonce, pub, pri)
-
-	return msg, nil
+	return privKey.SealTo(*pubKey, b), nil
 }
 
 func (h *Headscale) getAvailableIP() (*netaddr.IP, error) {