Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package edge
import (
"context"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/mldsa"
"crypto/rand"
"crypto/tls"
"crypto/x509"
"encoding/json/v2"
"encoding/pem"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"strings"
"testing"
"time"
certgen "github.com/getarcaneapp/arcane/cli/v2/pkg/generate"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
kit "go.getarcane.app/kit/pkg"
libcrypto "go.getarcane.app/sys/crypto"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
)
func TestMain(m *testing.M) {
libcrypto.InitEncryption(&libcrypto.Config{
EncryptionKey: "test-encryption-key-for-edge-mtls-32bytes-min",
Environment: "test",
})
os.Exit(m.Run())
}
func initEdgeTestCrypto(t *testing.T) {
t.Helper()
libcrypto.InitEncryption(&libcrypto.Config{
EncryptionKey: "test-encryption-key-for-edge-mtls-32bytes-min",
Environment: "test",
})
}
func TestPrepareManagerMTLSAssetsWithContext(t *testing.T) {
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}
require.NoError(t, PrepareManagerMTLSAssetsWithContext(t.Context(), cfg))
require.NotEmpty(t, cfg.EdgeMTLSCAFile)
require.FileExists(t, cfg.EdgeMTLSCAFile)
configured := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
EdgeMTLSCAFile: filepath.Join(t.TempDir(), "ca.crt"),
}
require.NoError(t, PrepareManagerMTLSAssetsWithContext(t.Context(), configured))
require.NoFileExists(t, filepath.Join(configured.EdgeMTLSAssetsDir, generatedMTLSCACertFileName))
}
func TestGenerateManagerClientMTLSAssetsWithContext(t *testing.T) {
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}
assets, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-123", "Lab Server")
require.NoError(t, err)
require.NotNil(t, assets)
require.Empty(t, cfg.EdgeMTLSCAFile)
clientCertPath, err := GeneratedManagerClientMTLSCertPath(cfg, "env-123")
require.NoError(t, err)
require.FileExists(t, clientCertPath)
require.Equal(t, "./arcane-edge-certs", assets.HostDirHint)
require.Len(t, assets.Files, 3)
require.Equal(t, "ca.crt", assets.Files[0].Name)
require.Contains(t, assets.Files[0].Content, "BEGIN CERTIFICATE")
require.Equal(t, "/app/data/edge-mtls-agent/ca.crt", assets.Files[0].ContainerPath)
require.Equal(t, "/app/data/edge-mtls-agent/agent.crt", assets.Files[1].ContainerPath)
require.Equal(t, "agent.key", assets.Files[2].Name)
require.Equal(t, "/app/data/edge-mtls-agent/agent.key", assets.Files[2].ContainerPath)
require.Contains(t, assets.Files[2].Content, "BEGIN PRIVATE KEY")
keyBlock, _ := pem.Decode([]byte(assets.Files[2].Content))
require.NotNil(t, keyBlock)
parsedKey, err := x509.ParsePKCS8PrivateKey(keyBlock.Bytes)
require.NoError(t, err)
privateKey, ok := parsedKey.(*mldsa.PrivateKey)
require.True(t, ok)
require.Equal(t, mldsa.MLDSA87(), privateKey.PublicKey().Parameters())
certBlock, _ := pem.Decode([]byte(assets.Files[1].Content))
require.NotNil(t, certBlock)
cert, err := x509.ParseCertificate(certBlock.Bytes)
require.NoError(t, err)
publicKey, ok := cert.PublicKey.(*mldsa.PublicKey)
require.True(t, ok)
require.Equal(t, mldsa.MLDSA87(), publicKey.Parameters())
require.Equal(t, "Lab-Server-env-123", cert.Subject.CommonName)
require.Len(t, cert.URIs, 1)
require.Equal(t, "spiffe://manager.example.com/edge/env-123", cert.URIs[0].String())
}
func TestGeneratedClientCertificate_IncludesSANs(t *testing.T) {
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}
assets, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-abc", "Lab Server")
require.NoError(t, err)
require.NotNil(t, assets)
var certPEM string
for _, file := range assets.Files {
if file.Name == generatedMTLSClientCertName {
certPEM = file.Content
break
}
}
require.NotEmpty(t, certPEM, "agent cert must be in generated assets")
block, _ := pem.Decode([]byte(certPEM))
require.NotNil(t, block)
cert, err := x509.ParseCertificate(block.Bytes)
require.NoError(t, err)
require.NotEmpty(t, cert.URIs, "agent cert must include URI SAN for stable identity")
uri := cert.URIs[0]
require.Equal(t, "spiffe", uri.Scheme)
require.Equal(t, "manager.example.com", uri.Host)
require.Equal(t, "/edge/env-abc", uri.Path)
require.Contains(t, cert.DNSNames, "arcane-agent")
require.Contains(t, cert.DNSNames, "Lab-Server.agent.manager.example.com")
require.True(t, cert.NotBefore.Before(cert.NotAfter))
skew := cert.NotAfter.Sub(cert.NotBefore)
require.Positive(t, skew)
}
func TestEnsureAgentMTLSAssets_RejectsPlainHTTPEnrollment(t *testing.T) {
cfg := &Config{
ManagerApiUrl: "http://manager.example.com/api",
AgentToken: "valid-token",
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
}
err := EnsureAgentMTLSAssets(t.Context(), cfg)
require.Error(t, err)
require.Contains(t, err.Error(), "MANAGER_API_URL to use https for certificate enrollment")
cfg.EdgeMTLSCertFile = filepath.Join(t.TempDir(), "agent.crt")
cfg.EdgeMTLSKeyFile = filepath.Join(t.TempDir(), "agent.key")
require.NoError(t, EnsureAgentMTLSAssets(t.Context(), cfg), "configured client files skip enrollment")
}
func TestEnsureAgentMTLSAssets_LimitsEnrollmentErrorBody(t *testing.T) {
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte(strings.Repeat("a", maxEnrollResponseBytes*2)))
}))
t.Cleanup(server.Close)
caPath := filepath.Join(t.TempDir(), "manager.crt")
require.NoError(t, os.WriteFile(caPath, pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE",
Bytes: server.Certificate().Raw,
}), 0o600))
cfg := &Config{
ManagerApiUrl: server.URL + "/api",
AgentToken: "valid-token",
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caPath,
EdgeMTLSAssetsDir: t.TempDir(),
}
err := EnsureAgentMTLSAssets(t.Context(), cfg)
require.Error(t, err)
require.Contains(t, err.Error(), "edge mTLS enrollment failed with status 500")
require.LessOrEqual(t, len(err.Error()), maxEnrollResponseBytes+128)
}
func TestEnsureAgentMTLSAssets_EnrollsWithoutUnusableGeneratedCert(t *testing.T) {
generated, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}, "env-renew", "Renew")
require.NoError(t, err)
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.TLS == nil || len(r.TLS.PeerCertificates) > 0 {
w.WriteHeader(http.StatusBadRequest)
return
}
_ = json.MarshalWrite(w, enrollMTLSResponse{Files: generated.Files})
}))
t.Cleanup(server.Close)
caPath := filepath.Join(t.TempDir(), "manager.crt")
require.NoError(t, os.WriteFile(caPath, pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE",
Bytes: server.Certificate().Raw,
}), 0o600))
assetsDir := filepath.Join(t.TempDir(), "assets")
require.NoError(t, os.MkdirAll(assetsDir, 0o700))
certPath := filepath.Join(assetsDir, generatedMTLSClientCertName)
keyPath := filepath.Join(assetsDir, generatedMTLSClientKeyName)
require.NoError(t, os.WriteFile(certPath, []byte("not a certificate"), 0o600))
require.NoError(t, os.WriteFile(keyPath, []byte("not a key"), 0o600))
cfg := &Config{
ManagerApiUrl: server.URL + "/api",
AgentToken: "valid-token",
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caPath,
EdgeMTLSCertFile: certPath,
EdgeMTLSKeyFile: keyPath,
EdgeMTLSAssetsDir: assetsDir,
}
require.NoError(t, EnsureAgentMTLSAssets(t.Context(), cfg))
_, reason := loadClientCertificate(certPath, keyPath, time.Now(), 0)
require.Empty(t, reason)
}
func TestEnsureAgentMTLSAssets_UsesDownloadedCAPathWhenPresent(t *testing.T) {
assetsDir := t.TempDir()
caPath := filepath.Join(assetsDir, generatedMTLSCACertFileName)
generated, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}, "env-existing", "Existing")
require.NoError(t, err)
require.NotNil(t, generated)
for _, file := range generated.Files {
targetPath := filepath.Join(assetsDir, filepath.Base(file.Name))
perm := kit.Ternary(file.Permissions == "0600", 0o600, utils.FilePerm)
require.NoError(t, os.WriteFile(targetPath, []byte(file.Content), perm))
}
cfg := &Config{
ManagerApiUrl: "https://manager.example.com/api",
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: assetsDir,
}
require.NoError(t, EnsureAgentMTLSAssets(t.Context(), cfg))
require.NotEmpty(t, cfg.EdgeMTLSCertFile)
require.NotEmpty(t, cfg.EdgeMTLSKeyFile)
require.FileExists(t, cfg.EdgeMTLSCertFile)
require.FileExists(t, cfg.EdgeMTLSKeyFile)
require.Equal(t, caPath, cfg.EdgeMTLSCAFile)
}
func TestRemoveStaleLock_PreservesLivePID(t *testing.T) {
lockPath := filepath.Join(t.TempDir(), ".ca.lock")
require.NoError(t, os.WriteFile(lockPath, fmt.Appendf(nil, "%d %s\n", os.Getpid(), time.Now().UTC().Format(time.RFC3339Nano)), 0o600))
require.False(t, removeStaleLock(lockPath))
require.FileExists(t, lockPath)
}
func TestRemoveStaleLock_RemovesOldLockDespiteLivePID(t *testing.T) {
lockPath := filepath.Join(t.TempDir(), ".ca.lock")
oldTimestamp := time.Now().Add(-(2*managerCALockTimeout + time.Second)).UTC().Format(time.RFC3339Nano)
require.NoError(t, os.WriteFile(lockPath, fmt.Appendf(nil, "%d %s\n", os.Getpid(), oldTimestamp), 0o600))
require.True(t, removeStaleLock(lockPath))
require.NoFileExists(t, lockPath)
}
func TestBuildManagerClientTLSConfig_OptionalIgnoresBrokenClientCertificate(t *testing.T) {
assetsDir := t.TempDir()
certPath := filepath.Join(assetsDir, generatedMTLSClientCertName)
keyPath := filepath.Join(assetsDir, generatedMTLSClientKeyName)
require.NoError(t, os.WriteFile(certPath, []byte("not a cert"), 0o644))
require.NoError(t, os.WriteFile(keyPath, []byte("not a key"), 0o600))
tlsConfig, err := buildManagerClientTLSConfig(&Config{
ManagerApiUrl: "https://manager.example.com",
EdgeMTLSMode: EdgeMTLSModeOptional,
EdgeMTLSCertFile: certPath,
EdgeMTLSKeyFile: keyPath,
})
require.NoError(t, err)
require.NotNil(t, tlsConfig)
require.Empty(t, tlsConfig.Certificates)
}
func TestTunnelServerRequireCertificateIdentity_RejectsWrongEnvironmentURI(t *testing.T) {
uriSAN, err := url.Parse("spiffe://manager.example.com/edge/env-a")
require.NoError(t, err)
cert := &x509.Certificate{URIs: []*url.URL{uriSAN}}
state := &tls.ConnectionState{
PeerCertificates: []*x509.Certificate{cert},
VerifiedChains: [][]*x509.Certificate{{cert}},
}
server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.Config = &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
}
require.NoError(t, server.requireCertificateIdentity(state, "env-a"))
require.Error(t, server.requireCertificateIdentity(state, "env-b"))
server.Config.AppURL = "https://other.example.com"
require.Error(t, server.requireCertificateIdentity(state, "env-a"), "a different trust domain must not match")
}
func TestValidateManagerMTLSConfig_DoesNotRequireArcaneTLSTermination(t *testing.T) {
require.NoError(t, ValidateManagerMTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
}))
assetsDir := t.TempDir()
_, _, err := ensureManagerCA(t.Context(), assetsDir)
require.NoError(t, err)
caPath := filepath.Join(assetsDir, generatedMTLSCACertFileName)
err = ValidateManagerMTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caPath,
})
require.NoError(t, err)
}
func TestValidateManagerMTLSConfig_RejectsMissingOrMalformedCAFile(t *testing.T) {
t.Run("missing file", func(t *testing.T) {
err := ValidateManagerMTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: filepath.Join(t.TempDir(), "missing-ca.crt"),
})
require.Error(t, err)
require.Contains(t, err.Error(), "failed to load edge mTLS CA file")
})
t.Run("malformed file", func(t *testing.T) {
caPath := filepath.Join(t.TempDir(), "ca.crt")
require.NoError(t, os.WriteFile(caPath, []byte("not a pem"), 0o600))
err := ValidateManagerMTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caPath,
})
require.Error(t, err)
require.Contains(t, err.Error(), "failed to load edge mTLS CA file")
})
}
func TestTunnelServerRequiredMTLS_AllowsHTTPRequestsWithoutVisibleTLSState(t *testing.T) {
server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.Config = &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
}
req := httptest.NewRequest(http.MethodGet, "/api/tunnel/connect", http.NoBody)
require.NoError(t, server.requireCertificateIdentity(req.TLS, "env-a"))
}
func TestTunnelServerRequiredMTLS_RejectsDirectTLSWithoutVerifiedClientCertificate(t *testing.T) {
server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.Config = &Config{EdgeMTLSMode: EdgeMTLSModeRequired}
req := httptest.NewRequest(http.MethodGet, "https://manager.example.com/api/tunnel/connect", http.NoBody)
req.TLS = &tls.ConnectionState{}
require.ErrorContains(t, server.requireCertificateIdentity(req.TLS, "env-a"), "verified edge mTLS client certificate is required")
server.Config = &Config{EdgeMTLSMode: EdgeMTLSModeOptional}
require.NoError(t, server.requireCertificateIdentity(req.TLS, "env-a"))
}
func TestTunnelServerRequiredMTLS_DetectsOnlyDirectTLSForRequestSecurityMode(t *testing.T) {
server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.Config = &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
}
cert := &x509.Certificate{}
req := httptest.NewRequest(http.MethodGet, "/api/tunnel/connect", http.NoBody)
req.TLS = &tls.ConnectionState{
PeerCertificates: []*x509.Certificate{cert},
VerifiedChains: [][]*x509.Certificate{{cert}},
}
require.True(t, hasVerifiedPeerCertificate(req.TLS))
req = httptest.NewRequest(http.MethodGet, "/api/tunnel/connect", http.NoBody)
req.Header.Set("X-SSL-Client-Verify", "SUCCESS")
require.False(t, hasVerifiedPeerCertificate(req.TLS))
require.NoError(t, server.requireCertificateIdentity(req.TLS, "env-a"))
}
func TestLoadClientCertificate_RenewsExpiredCertificate(t *testing.T) {
assetsDir := t.TempDir()
assets, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}, "env-renew", "Renew")
require.NoError(t, err)
for _, file := range assets.Files {
targetPath := filepath.Join(assetsDir, filepath.Base(file.Name))
perm := kit.Ternary(file.Permissions == "0600", 0o600, utils.FilePerm)
require.NoError(t, os.WriteFile(targetPath, []byte(file.Content), perm))
}
certPath := filepath.Join(assetsDir, generatedMTLSClientCertName)
keyPath := filepath.Join(assetsDir, generatedMTLSClientKeyName)
cert, reason := loadClientCertificate(certPath, keyPath, time.Now(), agentMTLSRenewBefore)
require.Empty(t, reason)
_, reason = loadClientCertificate(certPath, keyPath, cert.Leaf.NotAfter.Add(24*time.Hour), agentMTLSRenewBefore)
require.Contains(t, reason, "expired")
}
func TestLoadClientCertificate_RenewBeforeOnlyAppliesWhenRequested(t *testing.T) {
assetsDir := t.TempDir()
assets, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}, "env-window", "Window")
require.NoError(t, err)
for _, file := range assets.Files {
targetPath := filepath.Join(assetsDir, filepath.Base(file.Name))
perm := kit.Ternary(file.Permissions == "0600", 0o600, utils.FilePerm)
require.NoError(t, os.WriteFile(targetPath, []byte(file.Content), perm))
}
certPath := filepath.Join(assetsDir, generatedMTLSClientCertName)
keyPath := filepath.Join(assetsDir, generatedMTLSClientKeyName)
cert, reason := loadClientCertificate(certPath, keyPath, time.Now(), 0)
require.Empty(t, reason)
nearExpiry := cert.Leaf.NotAfter.Add(-24 * time.Hour)
_, reason = loadClientCertificate(certPath, keyPath, nearExpiry, 0)
require.Empty(t, reason, "a certificate inside the renewal window stays usable when no window is requested")
_, reason = loadClientCertificate(certPath, keyPath, nearExpiry, agentMTLSRenewBefore)
require.Contains(t, reason, "expires soon")
}
func TestGenerateManagerClientMTLSAssets_ReissuesMismatchedKeyPair(t *testing.T) {
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}
_, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-123", "Lab Server")
require.NoError(t, err)
replacementKey, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
require.NoError(t, err)
replacementKeyDER, err := x509.MarshalECPrivateKey(replacementKey)
require.NoError(t, err)
clientKeyPath := filepath.Join(cfg.EdgeMTLSAssetsDir, generatedClientMTLSSubdir, "env-123", generatedMTLSClientKeyName)
require.NoError(t, os.WriteFile(clientKeyPath, pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: replacementKeyDER}), 0o600))
assets, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-123", "Lab Server")
require.NoError(t, err)
require.True(t, assets.CertIssued, "a key that no longer matches the certificate must be reissued")
_, err = tls.X509KeyPair([]byte(assets.Files[1].Content), []byte(assets.Files[2].Content))
require.NoError(t, err)
}
func TestGenerateManagerClientMTLSAssets_PreservesCertificateWhenEnvironmentNameChanges(t *testing.T) {
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
AppURL: "https://manager.example.com",
}
original, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-123", "")
require.NoError(t, err)
renamed, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-123", "Lab Server")
require.NoError(t, err)
require.False(t, renamed.CertIssued)
require.Equal(t, original.Files[1].Content, renamed.Files[1].Content)
certBlock, _ := pem.Decode([]byte(renamed.Files[1].Content))
require.NotNil(t, certBlock)
cert, err := x509.ParseCertificate(certBlock.Bytes)
require.NoError(t, err)
require.Equal(t, "env-123", cert.Subject.CommonName)
}
func TestCAKey_EncryptedOnDiskWhenCryptoInitialized(t *testing.T) {
initEdgeTestCrypto(t)
assetsDir := t.TempDir()
ca, generated, err := ensureManagerCA(t.Context(), assetsDir)
require.NoError(t, err)
require.True(t, generated)
raw, err := os.ReadFile(filepath.Join(assetsDir, generatedMTLSCAKeyFileName))
require.NoError(t, err)
require.True(t, strings.HasPrefix(string(raw), caKeyEncryptedPrefix))
require.NotContains(t, string(raw), "BEGIN PRIVATE KEY", "encrypted CA key file must not contain plain PEM markers")
reused, generated, err := ensureManagerCA(t.Context(), assetsDir)
require.NoError(t, err)
require.False(t, generated, "the encrypted CA key must decrypt and be reused")
require.Equal(t, ca.Certificate, reused.Certificate)
_, err = GenerateManagerClientMTLSAssetsWithContext(t.Context(), &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: assetsDir,
AppURL: "https://manager.example.com",
}, "env-round", "Round Trip")
require.NoError(t, err)
}
func TestCAKey_EncryptionFailureReturnsError(t *testing.T) {
originalEncrypt := caKeyEncrypt
t.Cleanup(func() {
caKeyEncrypt = originalEncrypt
})
caKeyEncrypt = func(string) (string, error) {
return "", errors.New("encrypt failed")
}
assetsDir := t.TempDir()
_, _, err := ensureManagerCA(t.Context(), assetsDir)
require.Error(t, err)
require.Contains(t, err.Error(), "failed to encrypt edge mTLS CA private key")
require.NoFileExists(t, filepath.Join(assetsDir, generatedMTLSCAKeyFileName))
}
func TestLockEdgeMTLSPath_ReturnsOnContextCancellation(t *testing.T) {
assetsDir := t.TempDir()
unlock, err := lockEdgeMTLSPath(t.Context(), assetsDir, ".ca.lock")
require.NoError(t, err)
defer unlock()
ctx, cancel := context.WithCancel(t.Context())
cancel()
_, err = lockEdgeMTLSPath(ctx, assetsDir, ".ca.lock")
require.Error(t, err)
require.Contains(t, err.Error(), "cancelled waiting for edge mTLS CA lock")
}
func TestCAKey_EmptyEncryptionPayloadReturnsError(t *testing.T) {
originalEncrypt := caKeyEncrypt
t.Cleanup(func() {
caKeyEncrypt = originalEncrypt
})
caKeyEncrypt = func(string) (string, error) {
return "", nil
}
assetsDir := t.TempDir()
_, _, err := ensureManagerCA(t.Context(), assetsDir)
require.Error(t, err)
require.Contains(t, err.Error(), "encrypted payload is empty")
require.NoFileExists(t, filepath.Join(assetsDir, generatedMTLSCAKeyFileName))
}
func TestGeneratedMLDSAAssets_HandshakeWithVerifiedClientCertificate(t *testing.T) {
assetsDir := t.TempDir()
cfg := &Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: assetsDir,
AppURL: "https://manager.example.com",
}
_, err := GenerateManagerClientMTLSAssetsWithContext(t.Context(), cfg, "env-hs", "Handshake")
require.NoError(t, err)
caCertPath := filepath.Join(assetsDir, "ca.crt")
ca, caGenerated, err := ensureManagerCA(t.Context(), assetsDir)
require.NoError(t, err)
require.False(t, caGenerated)
serverKey, err := certgen.GenerateMLDSA87PrivateKey()
require.NoError(t, err)
serverTemplate, err := certgen.NewServerTLSTemplate("localhost", []string{"localhost", "127.0.0.1"})
require.NoError(t, err)
serverDER, err := x509.CreateCertificate(rand.Reader, serverTemplate, ca.Leaf, serverKey.PublicKey(), ca.PrivateKey)
require.NoError(t, err)
serverTLS, err := BuildManagerServerTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caCertPath,
})
require.NoError(t, err)
require.NotNil(t, serverTLS)
serverTLS.Certificates = []tls.Certificate{{Certificate: [][]byte{serverDER}, PrivateKey: serverKey}}
clientCertPath, err := GeneratedManagerClientMTLSCertPath(cfg, "env-hs")
require.NoError(t, err)
clientTLS, err := buildManagerClientTLSConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSCAFile: caCertPath,
EdgeMTLSCertFile: clientCertPath,
EdgeMTLSKeyFile: filepath.Join(filepath.Dir(clientCertPath), "agent.key"),
EdgeMTLSServerName: "localhost",
ManagerApiUrl: "https://localhost/api",
})
require.NoError(t, err)
require.NotNil(t, clientTLS)
require.Equal(t, uint16(tls.VersionTLS13), clientTLS.MinVersion)
listener, err := tls.Listen("tcp", "127.0.0.1:0", serverTLS)
require.NoError(t, err)
defer func() { assert.NoError(t, listener.Close()) }()
type handshakeResult struct {
state tls.ConnectionState
err error
}
resultCh := make(chan handshakeResult, 1)
go func() {
conn, acceptErr := listener.Accept()
if acceptErr != nil {
resultCh <- handshakeResult{err: acceptErr}
return
}
defer func() { assert.NoError(t, conn.Close()) }()
tlsConn := conn.(*tls.Conn)
if handshakeErr := tlsConn.Handshake(); handshakeErr != nil {
resultCh <- handshakeResult{err: handshakeErr}
return
}
resultCh <- handshakeResult{state: tlsConn.ConnectionState()}
}()
conn, err := tls.Dial("tcp", listener.Addr().String(), clientTLS)
require.NoError(t, err)
defer func() { assert.NoError(t, conn.Close()) }()
require.Equal(t, uint16(tls.VersionTLS13), conn.ConnectionState().Version)
result := <-resultCh
require.NoError(t, result.err)
require.Equal(t, uint16(tls.VersionTLS13), result.state.Version)
require.True(t, hasVerifiedPeerCertificate(&result.state))
server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.Config = cfg
require.NoError(t, server.requireCertificateIdentity(&result.state, "env-hs"))
}