feat: add cluster token encryption

backend/internal/encryption/cipher.go

@@ -0,0 +1,79 @@
+package encryption
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
+)
+
+const (
+	currentVersion byte = 1
+	keySize             = 32
+)
+
+type Cipher struct {
+	gcm cipher.AEAD
+}
+
+func New(masterKey []byte) (Cipher, error) {
+	if len(masterKey) != keySize {
+		return Cipher{}, fmt.Errorf("master key must be %d bytes", keySize)
+	}
+
+	block, err := aes.NewCipher(masterKey)
+	if err != nil {
+		return Cipher{}, err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return Cipher{}, err
+	}
+
+	return Cipher{gcm: gcm}, nil
+}
+
+func NewFromBase64(encodedKey string) (Cipher, error) {
+	encodedKey = strings.TrimSpace(encodedKey)
+	if encodedKey == "" {
+		return Cipher{}, fmt.Errorf("MASTER_KEY_BASE64 is required")
+	}
+
+	key, err := base64.StdEncoding.DecodeString(encodedKey)
+	if err != nil {
+		return Cipher{}, fmt.Errorf("MASTER_KEY_BASE64 must be base64 encoded: %w", err)
+	}
+
+	return New(key)
+}
+
+func (c Cipher) Encrypt(plaintext []byte) ([]byte, error) {
+	nonce := make([]byte, c.gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return nil, err
+	}
+
+	ciphertext := make([]byte, 0, 1+len(nonce)+len(plaintext)+c.gcm.Overhead())
+	ciphertext = append(ciphertext, currentVersion)
+	ciphertext = append(ciphertext, nonce...)
+	ciphertext = c.gcm.Seal(ciphertext, nonce, plaintext, nil)
+	return ciphertext, nil
+}
+
+func (c Cipher) Decrypt(ciphertext []byte) ([]byte, error) {
+	nonceSize := c.gcm.NonceSize()
+	if len(ciphertext) < 1+nonceSize+c.gcm.Overhead() {
+		return nil, fmt.Errorf("ciphertext is too short")
+	}
+	if ciphertext[0] != currentVersion {
+		return nil, fmt.Errorf("unsupported ciphertext version")
+	}
+
+	nonce := ciphertext[1 : 1+nonceSize]
+	encrypted := ciphertext[1+nonceSize:]
+	return c.gcm.Open(nil, nonce, encrypted, nil)
+}

backend/internal/encryption/cipher_test.go

@@ -0,0 +1,96 @@
+package encryption
+
+import (
+	"bytes"
+	"encoding/base64"
+	"strings"
+	"testing"
+)
+
+func TestCipherRoundtrip(t *testing.T) {
+	cipher, err := New(bytes.Repeat([]byte{1}, keySize))
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	plaintext := []byte("secret-proxmox-token")
+	ciphertext, err := cipher.Encrypt(plaintext)
+	if err != nil {
+		t.Fatalf("Encrypt() error = %v", err)
+	}
+	if bytes.Contains(ciphertext, plaintext) {
+		t.Fatal("ciphertext contains plaintext")
+	}
+	if ciphertext[0] != currentVersion {
+		t.Fatalf("version = %d, want %d", ciphertext[0], currentVersion)
+	}
+
+	got, err := cipher.Decrypt(ciphertext)
+	if err != nil {
+		t.Fatalf("Decrypt() error = %v", err)
+	}
+	if string(got) != string(plaintext) {
+		t.Fatalf("plaintext = %q, want %q", got, plaintext)
+	}
+}
+
+func TestDecryptRejectsWrongKey(t *testing.T) {
+	cipherA, err := New(bytes.Repeat([]byte{1}, keySize))
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+	cipherB, err := New(bytes.Repeat([]byte{2}, keySize))
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	ciphertext, err := cipherA.Encrypt([]byte("secret-proxmox-token"))
+	if err != nil {
+		t.Fatalf("Encrypt() error = %v", err)
+	}
+
+	if _, err := cipherB.Decrypt(ciphertext); err == nil {
+		t.Fatal("Decrypt() error = nil, want error")
+	}
+}
+
+func TestDecryptRejectsUnknownVersion(t *testing.T) {
+	cipher, err := New(bytes.Repeat([]byte{1}, keySize))
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	ciphertext, err := cipher.Encrypt([]byte("secret-proxmox-token"))
+	if err != nil {
+		t.Fatalf("Encrypt() error = %v", err)
+	}
+	ciphertext[0] = 99
+
+	if _, err := cipher.Decrypt(ciphertext); err == nil {
+		t.Fatal("Decrypt() error = nil, want error")
+	}
+}
+
+func TestNewRejectsInvalidKeySize(t *testing.T) {
+	if _, err := New(bytes.Repeat([]byte{1}, keySize-1)); err == nil {
+		t.Fatal("New() error = nil, want error")
+	}
+}
+
+func TestNewFromBase64(t *testing.T) {
+	encoded := base64.StdEncoding.EncodeToString(bytes.Repeat([]byte{1}, keySize))
+
+	if _, err := NewFromBase64(encoded); err != nil {
+		t.Fatalf("NewFromBase64() error = %v", err)
+	}
+}
+
+func TestNewFromBase64RejectsMissingKey(t *testing.T) {
+	_, err := NewFromBase64("")
+	if err == nil {
+		t.Fatal("NewFromBase64() error = nil, want error")
+	}
+	if !strings.Contains(err.Error(), "MASTER_KEY_BASE64") {
+		t.Fatalf("error = %q, want MASTER_KEY_BASE64 hint", err)
+	}
+}