Skip to content

Modern Docker Management, Designed for Everyone

fix: validate and secure remote template registry fetching (#2299)

Kyle Mendell8e67b3b1ff5e
diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.go
index 1e8fca548..411dadfeb 100644
--- a/backend/internal/common/errors.go
+++ b/backend/internal/common/errors.go
@@ -1013,7 +1013,7 @@ type RegistryFetchError struct {
}
func (e *RegistryFetchError) Error() string {
- return fmt.Sprintf("Failed to fetch registry: %v", e.Err)
+ return "Failed to fetch registry"
}
type InvalidJSONResponseError struct {
@@ -1021,7 +1021,15 @@ type InvalidJSONResponseError struct {
}
func (e *InvalidJSONResponseError) Error() string {
- return fmt.Sprintf("Invalid JSON response: %v", e.Err)
+ return "Invalid JSON response"
+}
+
+type UnsafeRemoteURLError struct {
+ Err error
+}
+
+func (e *UnsafeRemoteURLError) Error() string {
+ return fmt.Sprintf("Remote URL is not allowed: %v", e.Err)
}
type TemplateAlreadyLocalError struct{}
diff --git a/backend/internal/huma/handlers/templates.go b/backend/internal/huma/handlers/templates.go
index 19d960a0f..4141dba25 100644
--- a/backend/internal/huma/handlers/templates.go
+++ b/backend/internal/huma/handlers/templates.go
@@ -185,6 +185,10 @@ func RegisterTemplates(api huma.API, templateService *services.TemplateService,
Summary: "Fetch remote registry",
Description: "Fetch templates from a remote registry URL",
Tags: []string{"Templates"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
}, h.FetchRegistry)
huma.Register(api, huma.Operation{
diff --git a/backend/internal/huma/handlers/templates_fetch_test.go b/backend/internal/huma/handlers/templates_fetch_test.go
new file mode 100644
index 000000000..dc27da555
--- /dev/null
+++ b/backend/internal/huma/handlers/templates_fetch_test.go
@@ -0,0 +1,172 @@
+package handlers
+
+import (
+ "context"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/danielgtaylor/huma/v2"
+ "github.com/danielgtaylor/huma/v2/adapters/humagin"
+ "github.com/getarcaneapp/arcane/backend/internal/config"
+ "github.com/getarcaneapp/arcane/backend/internal/database"
+ humamiddleware "github.com/getarcaneapp/arcane/backend/internal/huma/middleware"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/services"
+ httputils "github.com/getarcaneapp/arcane/backend/pkg/utils/httpx"
+ "github.com/gin-gonic/gin"
+ glsqlite "github.com/glebarez/sqlite"
+ "github.com/golang-jwt/jwt/v5"
+ "github.com/stretchr/testify/require"
+ "gorm.io/gorm"
+)
+
+func TestFetchTemplateRegistryRequiresAuthentication(t *testing.T) {
+ router := newTemplateFetchTestRouter(t, http.DefaultClient, httputils.DefaultLookupIP)
+
+ req := httptest.NewRequest(http.MethodGet, "/api/templates/fetch?url=http://example.com/registry.json", nil)
+ rec := httptest.NewRecorder()
+
+ router.ServeHTTP(rec, req)
+
+ require.Equal(t, http.StatusUnauthorized, rec.Code)
+ require.Contains(t, rec.Body.String(), "Unauthorized")
+}
+
+func TestFetchTemplateRegistryAuthenticatedSuccess(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"name":"Registry","description":"Demo","version":"1.0.0","author":"Arcane","templates":[]}`))
+ }))
+ defer server.Close()
+
+ client, lookupIP, registryURL := makeTemplateFetchRemote(t, server)
+ router := newTemplateFetchTestRouter(t, client, lookupIP)
+
+ req := httptest.NewRequest(http.MethodGet, "/api/templates/fetch?url="+url.QueryEscape(registryURL), nil)
+ req.Header.Set("Authorization", "Bearer "+makeTemplateFetchToken(t, "test-secret", "user-1", "alice"))
+ rec := httptest.NewRecorder()
+
+ router.ServeHTTP(rec, req)
+
+ require.Equal(t, http.StatusOK, rec.Code)
+ require.Contains(t, rec.Body.String(), `"success":true`)
+ require.Contains(t, rec.Body.String(), `"name":"Registry"`)
+}
+
+func TestFetchTemplateRegistryAuthenticatedUnsafeTargetIsSanitized(t *testing.T) {
+ router := newTemplateFetchTestRouter(t, http.DefaultClient, httputils.DefaultLookupIP)
+
+ req := httptest.NewRequest(http.MethodGet, "/api/templates/fetch?url="+url.QueryEscape("http://127.0.0.1:8080/registry.json"), nil)
+ req.Header.Set("Authorization", "Bearer "+makeTemplateFetchToken(t, "test-secret", "user-1", "alice"))
+ rec := httptest.NewRecorder()
+
+ router.ServeHTTP(rec, req)
+
+ require.Equal(t, http.StatusBadGateway, rec.Code)
+ require.Contains(t, rec.Body.String(), "Failed to fetch registry")
+ require.NotContains(t, rec.Body.String(), "127.0.0.1")
+ require.NotContains(t, rec.Body.String(), "connection refused")
+ require.NotContains(t, rec.Body.String(), "Invalid JSON response")
+}
+
+func newTemplateFetchTestRouter(t *testing.T, httpClient *http.Client, lookupIP httputils.LookupIPFunc) *gin.Engine {
+ t.Helper()
+
+ originalDir, err := os.Getwd()
+ require.NoError(t, err)
+ require.NoError(t, os.Chdir(t.TempDir()))
+ t.Cleanup(func() {
+ require.NoError(t, os.Chdir(originalDir))
+ })
+
+ db, err := gorm.Open(glsqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, db.AutoMigrate(&models.User{}))
+
+ databaseDB := &database.DB{DB: db}
+ userService := services.NewUserService(databaseDB)
+ _, err = userService.CreateUser(context.Background(), &models.User{
+ BaseModel: models.BaseModel{ID: "user-1"},
+ Username: "alice",
+ Roles: models.StringSlice{"admin"},
+ })
+ require.NoError(t, err)
+
+ authService := services.NewAuthService(userService, nil, nil, "test-secret", &config.Config{})
+ templateService := services.NewTemplateService(context.Background(), nil, httpClient, nil).WithLookupIPResolver(lookupIP)
+
+ router := gin.New()
+ apiGroup := router.Group("/api")
+
+ humaConfig := huma.DefaultConfig("test", "1.0.0")
+ humaConfig.Components.SecuritySchemes = map[string]*huma.SecurityScheme{
+ "BearerAuth": {
+ Type: "http",
+ Scheme: "bearer",
+ },
+ "ApiKeyAuth": {
+ Type: "apiKey",
+ In: "header",
+ Name: "X-API-Key",
+ },
+ }
+
+ api := humagin.NewWithGroup(router, apiGroup, humaConfig)
+ api.UseMiddleware(humamiddleware.NewAuthBridge(api, authService, nil, &config.Config{}))
+ RegisterTemplates(api, templateService, nil)
+
+ return router
+}
+
+func makeTemplateFetchToken(t *testing.T, secret string, userID, username string) string {
+ t.Helper()
+
+ claims := services.UserClaims{
+ RegisteredClaims: jwt.RegisteredClaims{
+ ID: userID,
+ Subject: "access",
+ IssuedAt: jwt.NewNumericDate(time.Now()),
+ ExpiresAt: jwt.NewNumericDate(time.Now().Add(5 * time.Minute)),
+ },
+ UserID: userID,
+ Username: username,
+ Roles: []string{"admin"},
+ AppVersion: config.Version,
+ }
+
+ token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+ signed, err := token.SignedString([]byte(secret))
+ require.NoError(t, err)
+
+ return signed
+}
+
+func makeTemplateFetchRemote(t *testing.T, server *httptest.Server) (*http.Client, httputils.LookupIPFunc, string) {
+ t.Helper()
+
+ parsedURL, err := url.Parse(server.URL)
+ require.NoError(t, err)
+
+ listenerAddr := server.Listener.Addr().String()
+ transport := http.DefaultTransport.(*http.Transport).Clone()
+ transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+ dialer := &net.Dialer{}
+ return dialer.DialContext(ctx, network, listenerAddr)
+ }
+
+ client := &http.Client{
+ Transport: transport,
+ Timeout: 10 * time.Second,
+ }
+
+ lookupIP := func(ctx context.Context, host string) ([]net.IP, error) {
+ return []net.IP{net.ParseIP("93.184.216.34")}, nil
+ }
+
+ return client, lookupIP, "http://templates.example.test:" + parsedURL.Port() + "/registry.json"
+}
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 0e1f1999f..8df950f61 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -23,6 +23,7 @@ import (
"github.com/getarcaneapp/arcane/backend/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/pkg/projects"
"github.com/getarcaneapp/arcane/backend/pkg/utils"
+ httputils "github.com/getarcaneapp/arcane/backend/pkg/utils/httpx"
"github.com/getarcaneapp/arcane/backend/pkg/utils/mapper"
"github.com/getarcaneapp/arcane/types/env"
tmpl "github.com/getarcaneapp/arcane/types/template"
@@ -45,6 +46,8 @@ type registryFetchMeta struct {
type TemplateService struct {
db *database.DB
httpClient *http.Client
+ safeHTTPClient *http.Client
+ lookupIP httputils.LookupIPFunc
settingsService *SettingsService
remoteMu sync.RWMutex
@@ -81,13 +84,22 @@ func NewTemplateService(ctx context.Context, db *database.DB, httpClient *http.C
slog.WarnContext(ctx, "failed to ensure default templates", "error", err)
}
- return &TemplateService{
+ service := &TemplateService{
db: db,
httpClient: httpClient,
+ lookupIP: httputils.DefaultLookupIP,
settingsService: settingsService,
remoteCache: remoteCache{},
registryFetchMeta: make(map[string]*registryFetchMeta),
}
+ service.safeHTTPClient = service.newSafeHTTPClientInternal()
+ return service
+}
+
+func (s *TemplateService) WithLookupIPResolver(lookupIP httputils.LookupIPFunc) *TemplateService {
+ s.lookupIP = lookupIP
+ s.safeHTTPClient = s.newSafeHTTPClientInternal()
+ return s
}
func (s *TemplateService) ensureRemoteTemplatesLoaded(ctx context.Context) error {
@@ -554,11 +566,11 @@ func (s *TemplateService) FetchRaw(ctx context.Context, url string) ([]byte, err
}
func (s *TemplateService) doGET(ctx context.Context, url string) ([]byte, error) {
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ client, req, err := s.newSafeRequestInternal(ctx, http.MethodGet, url)
if err != nil {
- return nil, fmt.Errorf("failed to create request for %s: %w", url, err)
+ return nil, err
}
- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to configured template registry URL
+ resp, err := client.Do(req) //nolint:gosec // intentional request to configured template registry URL
if err != nil {
return nil, fmt.Errorf("failed to fetch %s: %w", url, err)
}
@@ -582,7 +594,7 @@ func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *model
fetchMeta := s.registryFetchMeta[reg.ID]
s.registryMu.RUnlock()
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, reg.URL, nil)
+ client, req, err := s.newSafeRequestInternal(ctx, http.MethodGet, reg.URL)
if err != nil {
return nil, fmt.Errorf("create request: %w", err)
}
@@ -590,7 +602,7 @@ func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *model
req.Header.Set("If-Modified-Since", fetchMeta.LastModified)
}
- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to configured template registry URL
+ resp, err := client.Do(req) //nolint:gosec // intentional request to configured template registry URL
if err != nil {
return nil, fmt.Errorf("request failed: %w", err)
}
@@ -737,6 +749,38 @@ func (s *TemplateService) fetchURL(ctx context.Context, url string) (string, err
return string(body), nil
}
+func (s *TemplateService) newSafeHTTPClientInternal() *http.Client {
+ client, err := httputils.NewSafeOutboundHTTPClient(s.httpClient, s.lookupIP)
+ if err != nil {
+ slog.Warn("failed to configure safe HTTP client", "error", err)
+ return nil
+ }
+ return client
+}
+
+func (s *TemplateService) newSafeRequestInternal(ctx context.Context, method, rawURL string) (*http.Client, *http.Request, error) {
+ parsedURL, err := httputils.ValidateSafeRemoteURL(ctx, rawURL, s.lookupIP)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ client := s.safeHTTPClient
+ if client == nil {
+ client = s.newSafeHTTPClientInternal()
+ if client == nil {
+ return nil, nil, fmt.Errorf("failed to configure safe HTTP client")
+ }
+ s.safeHTTPClient = client
+ }
+
+ req, err := http.NewRequestWithContext(ctx, method, parsedURL.String(), nil)
+ if err != nil {
+ return nil, nil, fmt.Errorf("failed to create request for %s: %w", rawURL, err)
+ }
+
+ return client, req, nil
+}
+
func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *models.ComposeTemplate) (*models.ComposeTemplate, error) {
if !remoteTemplate.IsRemote {
return nil, fmt.Errorf("template is not remote")
diff --git a/backend/internal/services/template_service_test.go b/backend/internal/services/template_service_test.go
index bf68c90b0..47ab4f7e7 100644
--- a/backend/internal/services/template_service_test.go
+++ b/backend/internal/services/template_service_test.go
@@ -2,19 +2,25 @@ package services
import (
"context"
+ "fmt"
+ "net"
"net/http"
"net/http/httptest"
+ "net/url"
"os"
"path/filepath"
"sync/atomic"
"testing"
+ "time"
glsqlite "github.com/glebarez/sqlite"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
+ "github.com/getarcaneapp/arcane/backend/internal/common"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ httputils "github.com/getarcaneapp/arcane/backend/pkg/utils/httpx"
)
func setupTemplateServiceTestDB(t *testing.T) *database.DB {
@@ -39,6 +45,32 @@ func setTestWorkingDir(t *testing.T, dir string) {
})
}
+func makePublicTestClient(t *testing.T, server *httptest.Server) (*http.Client, httputils.LookupIPFunc, string) {
+ t.Helper()
+
+ parsedURL, err := url.Parse(server.URL)
+ require.NoError(t, err)
+
+ listenerAddr := server.Listener.Addr().String()
+ transport := http.DefaultTransport.(*http.Transport).Clone()
+ transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+ dialer := &net.Dialer{}
+ return dialer.DialContext(ctx, network, listenerAddr)
+ }
+
+ client := &http.Client{
+ Transport: transport,
+ Timeout: 10 * time.Second,
+ }
+
+ lookupIP := func(ctx context.Context, host string) ([]net.IP, error) {
+ return []net.IP{net.ParseIP("93.184.216.34")}, nil
+ }
+
+ baseURL := fmt.Sprintf("http://templates.example.test:%s", parsedURL.Port())
+ return client, lookupIP, baseURL
+}
+
func TestResolveTemplateIconURL(t *testing.T) {
service := &TemplateService{}
@@ -164,12 +196,14 @@ services:
}))
defer server.Close()
- registryURL := server.URL + "/registry.json"
- okComposeURL = server.URL + "/ok.yml"
- badComposeURL = server.URL + "/missing.yml"
+ client, lookupIP, baseURL := makePublicTestClient(t, server)
+ registryURL := baseURL + "/registry.json"
+ okComposeURL = baseURL + "/ok.yml"
+ badComposeURL = baseURL + "/missing.yml"
service := &TemplateService{
- httpClient: server.Client(),
+ httpClient: client,
+ lookupIP: lookupIP,
registryFetchMeta: make(map[string]*registryFetchMeta),
}
registry := &models.TemplateRegistry{
@@ -218,9 +252,12 @@ services:
}))
defer server.Close()
+ client, lookupIP, baseURL := makePublicTestClient(t, server)
+
service := &TemplateService{
db: setupTemplateServiceTestDB(t),
- httpClient: server.Client(),
+ httpClient: client,
+ lookupIP: lookupIP,
registryFetchMeta: make(map[string]*registryFetchMeta),
}
@@ -232,8 +269,8 @@ services:
IsCustom: false,
RegistryID: stringPtr("reg-1"),
Metadata: &models.ComposeTemplateMetadata{
- RemoteURL: stringPtr(server.URL + "/compose.yaml"),
- EnvURL: stringPtr(server.URL + "/template.env"),
+ RemoteURL: stringPtr(baseURL + "/compose.yaml"),
+ EnvURL: stringPtr(baseURL + "/template.env"),
IconURL: stringPtr("https://cdn.example/download.png"),
},
}
@@ -253,6 +290,19 @@ services:
require.Equal(t, "https://cdn.example/download.png", *stored.Metadata.IconURL)
}
+func TestFetchRaw_BlocksUnsafeRemoteURL(t *testing.T) {
+ service := &TemplateService{
+ httpClient: http.DefaultClient,
+ lookupIP: httputils.DefaultLookupIP,
+ registryFetchMeta: make(map[string]*registryFetchMeta),
+ }
+
+ _, err := service.FetchRaw(context.Background(), "http://127.0.0.1:8080/registry.json")
+ require.Error(t, err)
+ var unsafeErr *common.UnsafeRemoteURLError
+ require.ErrorAs(t, err, &unsafeErr)
+}
+
func TestSyncFilesystemTemplatesInternal_PopulatesIconURL(t *testing.T) {
tempDir := t.TempDir()
setTestWorkingDir(t, tempDir)
diff --git a/backend/pkg/utils/httpx/safe_remote.go b/backend/pkg/utils/httpx/safe_remote.go
new file mode 100644
index 000000000..b73acf32f
--- /dev/null
+++ b/backend/pkg/utils/httpx/safe_remote.go
@@ -0,0 +1,232 @@
+package httpx
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net"
+ "net/http"
+ "net/netip"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/getarcaneapp/arcane/backend/internal/common"
+)
+
+type LookupIPFunc func(ctx context.Context, host string) ([]net.IP, error)
+
+// blockedRemotePrefixes contains special-use ranges that should never be treated
+// as valid public registry destinations. We intentionally keep this list explicit
+// because Go exposes helpers for some classes (for example private, loopback, and
+// link-local) but does not provide one "publicly routable on the internet" check
+// that covers the full SSRF threat model. These prefixes complement the net.IP
+// helper checks in isBlockedIPInternal and make the policy reviewable in one place.
+var blockedRemotePrefixes = mustParsePrefixesInternal(
+ "0.0.0.0/8",
+ "100.64.0.0/10",
+ "127.0.0.0/8",
+ "169.254.0.0/16",
+ "192.0.0.0/24",
+ "192.0.2.0/24",
+ "198.18.0.0/15",
+ "198.51.100.0/24",
+ "203.0.113.0/24",
+ "224.0.0.0/4",
+ "240.0.0.0/4",
+ "::/128",
+ "::1/128",
+ "2001:db8::/32",
+ "fc00::/7",
+ "fe80::/10",
+ "ff00::/8",
+)
+
+func DefaultLookupIP(ctx context.Context, host string) ([]net.IP, error) {
+ return net.DefaultResolver.LookupIP(ctx, "ip", host)
+}
+
+func ValidateSafeRemoteURL(ctx context.Context, rawURL string, lookupIP LookupIPFunc) (*url.URL, error) {
+ if lookupIP == nil {
+ lookupIP = DefaultLookupIP
+ }
+
+ parsed, err := url.Parse(rawURL)
+ if err != nil {
+ return nil, &common.UnsafeRemoteURLError{Err: err}
+ }
+
+ scheme := strings.ToLower(parsed.Scheme)
+ if scheme != "http" && scheme != "https" {
+ return nil, &common.UnsafeRemoteURLError{Err: fmt.Errorf("scheme %q is not allowed", parsed.Scheme)}
+ }
+
+ if parsed.User != nil {
+ return nil, &common.UnsafeRemoteURLError{Err: errors.New("embedded credentials are not allowed")}
+ }
+
+ host := parsed.Hostname()
+ if host == "" || isBlockedHostnameInternal(host) {
+ return nil, &common.UnsafeRemoteURLError{Err: fmt.Errorf("host %q is not allowed", host)}
+ }
+
+ ips, err := resolveAllowedIPsInternal(ctx, host, lookupIP)
+ if err != nil || len(ips) == 0 {
+ if err == nil {
+ err = errors.New("host did not resolve to an allowed IP")
+ }
+ return nil, &common.UnsafeRemoteURLError{Err: err}
+ }
+
+ return parsed, nil
+}
+
+func NewSafeOutboundHTTPClient(base *http.Client, lookupIP LookupIPFunc) (*http.Client, error) {
+ if lookupIP == nil {
+ lookupIP = DefaultLookupIP
+ }
+ if base == nil {
+ base = http.DefaultClient
+ }
+
+ transport, err := cloneHTTPTransportInternal(base.Transport)
+ if err != nil {
+ return nil, err
+ }
+
+ baseDial := transport.DialContext
+ if baseDial == nil {
+ dialer := &net.Dialer{
+ Timeout: 30 * time.Second,
+ KeepAlive: 30 * time.Second,
+ }
+ baseDial = dialer.DialContext
+ }
+
+ transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+ host, port, err := net.SplitHostPort(address)
+ if err != nil {
+ return nil, &common.UnsafeRemoteURLError{Err: err}
+ }
+
+ ips, err := resolveAllowedIPsInternal(ctx, host, lookupIP)
+ if err != nil {
+ return nil, err
+ }
+
+ var lastErr error
+ for _, ip := range ips {
+ conn, dialErr := baseDial(ctx, network, net.JoinHostPort(ip.String(), port))
+ if dialErr == nil {
+ return conn, nil
+ }
+ lastErr = dialErr
+ }
+
+ if lastErr != nil {
+ return nil, lastErr
+ }
+ return nil, fmt.Errorf("failed to resolve remote host")
+ }
+
+ client := *base
+ client.Transport = transport
+ client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+ if len(via) >= 10 {
+ return errors.New("stopped after 10 redirects")
+ }
+ if _, err := ValidateSafeRemoteURL(req.Context(), req.URL.String(), lookupIP); err != nil {
+ return err
+ }
+ if base.CheckRedirect != nil {
+ return base.CheckRedirect(req, via)
+ }
+ return nil
+ }
+
+ return &client, nil
+}
+
+func cloneHTTPTransportInternal(base http.RoundTripper) (*http.Transport, error) {
+ switch t := base.(type) {
+ case nil:
+ return http.DefaultTransport.(*http.Transport).Clone(), nil
+ case *http.Transport:
+ return t.Clone(), nil
+ default:
+ return nil, fmt.Errorf("unsupported HTTP transport type %T", base)
+ }
+}
+
+func resolveAllowedIPsInternal(ctx context.Context, host string, lookupIP LookupIPFunc) ([]net.IP, error) {
+ if parsedIP := parseIPLiteralInternal(host); parsedIP != nil {
+ if isBlockedIPInternal(parsedIP) {
+ return nil, &common.UnsafeRemoteURLError{Err: fmt.Errorf("IP %s is not allowed", parsedIP.String())}
+ }
+ return []net.IP{parsedIP}, nil
+ }
+
+ ips, err := lookupIP(ctx, host)
+ if err != nil {
+ return nil, err
+ }
+
+ allowed := make([]net.IP, 0, len(ips))
+ for _, ip := range ips {
+ if ip == nil {
+ continue
+ }
+ if isBlockedIPInternal(ip) {
+ return nil, &common.UnsafeRemoteURLError{Err: fmt.Errorf("IP %s is not allowed", ip.String())}
+ }
+ allowed = append(allowed, ip)
+ }
+
+ if len(allowed) == 0 {
+ return nil, &common.UnsafeRemoteURLError{Err: errors.New("host did not resolve to an allowed IP")}
+ }
+
+ return allowed, nil
+}
+
+func parseIPLiteralInternal(host string) net.IP {
+ host = strings.Trim(strings.TrimSpace(host), "[]")
+ if zoneIdx := strings.Index(host, "%"); zoneIdx != -1 {
+ host = host[:zoneIdx]
+ }
+ return net.ParseIP(host)
+}
+
+func isBlockedHostnameInternal(host string) bool {
+ host = strings.ToLower(strings.TrimSpace(host))
+ return host == "localhost" || strings.HasSuffix(host, ".localhost")
+}
+
+func isBlockedIPInternal(ip net.IP) bool {
+ if ip.IsLoopback() || ip.IsPrivate() || ip.IsMulticast() || ip.IsUnspecified() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
+ return true
+ }
+
+ // net.IP helper methods do not cover every special-use range we want to keep
+ // off-limits for remote registry fetching, so we also check the explicit prefix list above.
+ addr, ok := netip.AddrFromSlice(ip)
+ if !ok {
+ return true
+ }
+
+ for _, prefix := range blockedRemotePrefixes {
+ if prefix.Contains(addr.Unmap()) {
+ return true
+ }
+ }
+
+ return false
+}
+
+func mustParsePrefixesInternal(raw ...string) []netip.Prefix {
+ prefixes := make([]netip.Prefix, 0, len(raw))
+ for _, cidr := range raw {
+ prefixes = append(prefixes, netip.MustParsePrefix(cidr))
+ }
+ return prefixes
+}
diff --git a/backend/pkg/utils/httpx/safe_remote_test.go b/backend/pkg/utils/httpx/safe_remote_test.go
new file mode 100644
index 000000000..77c5c7af5
--- /dev/null
+++ b/backend/pkg/utils/httpx/safe_remote_test.go
@@ -0,0 +1,93 @@
+package httpx
+
+import (
+ "context"
+ "errors"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/getarcaneapp/arcane/backend/internal/common"
+ "github.com/stretchr/testify/require"
+)
+
+func TestValidateSafeRemoteURL(t *testing.T) {
+ lookupIP := func(ctx context.Context, host string) ([]net.IP, error) {
+ switch host {
+ case "registry.example.com":
+ return []net.IP{net.ParseIP("93.184.216.34")}, nil
+ case "internal.example.com":
+ return []net.IP{net.ParseIP("10.0.0.10")}, nil
+ default:
+ return nil, errors.New("unexpected host")
+ }
+ }
+
+ tests := []struct {
+ name string
+ rawURL string
+ wantErr bool
+ }{
+ {name: "allow public https", rawURL: "https://registry.example.com/templates.json"},
+ {name: "allow public http", rawURL: "http://registry.example.com/templates.json"},
+ {name: "reject missing host", rawURL: "https:///templates.json", wantErr: true},
+ {name: "reject unsupported scheme", rawURL: "ftp://registry.example.com/templates.json", wantErr: true},
+ {name: "reject schemeless", rawURL: "//registry.example.com/templates.json", wantErr: true},
+ {name: "reject credentials", rawURL: "https://user:[email protected]/templates.json", wantErr: true},
+ {name: "reject localhost", rawURL: "http://localhost:8080/templates.json", wantErr: true},
+ {name: "reject loopback literal", rawURL: "http://127.0.0.1:8080/templates.json", wantErr: true},
+ {name: "reject internal resolved host", rawURL: "https://internal.example.com/templates.json", wantErr: true},
+ {name: "reject file scheme", rawURL: "file:///etc/passwd", wantErr: true},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ parsed, err := ValidateSafeRemoteURL(context.Background(), tt.rawURL, lookupIP)
+ if tt.wantErr {
+ require.Error(t, err)
+ var unsafeErr *common.UnsafeRemoteURLError
+ require.ErrorAs(t, err, &unsafeErr)
+ require.Nil(t, parsed)
+ return
+ }
+
+ require.NoError(t, err)
+ require.NotNil(t, parsed)
+ })
+ }
+}
+
+func TestNewSafeOutboundHTTPClient_BlocksUnsafeRedirectTarget(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ http.Redirect(w, r, "http://127.0.0.1:8080/private", http.StatusFound)
+ }))
+ defer server.Close()
+
+ baseClient := newRedirectTestClient(server.Listener.Addr().String())
+ lookupIP := func(ctx context.Context, host string) ([]net.IP, error) {
+ return []net.IP{net.ParseIP("93.184.216.34")}, nil
+ }
+
+ client, err := NewSafeOutboundHTTPClient(baseClient, lookupIP)
+ require.NoError(t, err)
+
+ _, err = client.Get("http://registry.example.com/redirect")
+ require.Error(t, err)
+ var unsafeErr *common.UnsafeRemoteURLError
+ require.ErrorAs(t, err, &unsafeErr)
+}
+
+func newRedirectTestClient(listenerAddr string) *http.Client {
+ transport := http.DefaultTransport.(*http.Transport).Clone()
+ transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+ dialer := &net.Dialer{}
+ return dialer.DialContext(ctx, network, listenerAddr)
+ }
+
+ return &http.Client{
+ Transport: transport,
+ Timeout: 5 * time.Second,
+ }
+}
diff --git a/frontend/src/routes/(app)/containers/[containerId]/+page.svelte b/frontend/src/routes/(app)/containers/[containerId]/+page.svelte
index 6773a0259..d75352f21 100644
--- a/frontend/src/routes/(app)/containers/[containerId]/+page.svelte
+++ b/frontend/src/routes/(app)/containers/[containerId]/+page.svelte
@@ -199,9 +199,7 @@
return null;
}
- const serviceComposeSourcePromise = $derived(
- resolveServiceComposeSource(project, composeServiceName, composeInfo)
- );
+ const serviceComposeSourcePromise = $derived(resolveServiceComposeSource(project, composeServiceName, composeInfo));
const showComposeTab = $derived(!!composeInfo && !!project);
diff --git a/go.work.sum b/go.work.sum
index e59e25198..611cc4ff7 100644
--- a/go.work.sum
+++ b/go.work.sum
@@ -769,6 +769,7 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWb
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
@@ -992,6 +993,7 @@ go.etcd.io/etcd/server/v3 v3.5.6/go.mod h1:6/Gfe8XTGXQJgLYQ65oGKMfPivb2EASLUSMSW
go.mongodb.org/mongo-driver v1.7.5 h1:ny3p0reEpgsR2cfA5cjgwFZg3Cv/ofFh/8jbhGtz9VI=
go.mongodb.org/mongo-driver v1.7.5/go.mod h1:VXEWRZ6URJIkUq2SCAyapmhH0ZLRBP+FT4xhp5Zvxng=
go.mongodb.org/mongo-driver v1.17.6 h1:87JUG1wZfWsr6rIz3ZmpH90rL5tea7O3IHuSwHUpsss=
+go.mongodb.org/mongo-driver v1.17.6/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
go.opentelemetry.io/contrib/detectors/gcp v1.38.0 h1:ZoYbqX7OaA/TAikspPl3ozPI6iY6LiIY9I8cUfm+pJs=
go.opentelemetry.io/contrib/detectors/gcp v1.38.0/go.mod h1:SU+iU7nu5ud4oCb3LQOhIZ3nRLj6FNVrKgtflbaf2ts=