Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: validate and secure remote template registry fetching (#2299)
Kyle Mendell8e67b3b1ff5e
diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.goindex 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.goindex 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.gonew file mode 100644index 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.goindex 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.DBhttpClient *http.Client+ safeHTTPClient *http.Client+ lookupIP httputils.LookupIPFuncsettingsService *SettingsServiceremoteMu sync.RWMutex@@ -81,13 +84,22 @@ func NewTemplateService(ctx context.Context, db *database.DB, httpClient *http.Cslog.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 URLif 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 *modelfetchMeta := 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 *modelreq.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 URLif err != nil {return nil, fmt.Errorf("request failed: %w", err)}@@ -737,6 +749,38 @@ func (s *TemplateService) fetchURL(ctx context.Context, url string) (string, errreturn 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.goindex bf68c90b0..47ab4f7e7 100644--- a/backend/internal/services/template_service_test.go+++ b/backend/internal/services/template_service_test.go@@ -2,19 +2,25 @@ package servicesimport ("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.gonew file mode 100644index 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.gonew file mode 100644index 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.svelteindex 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.sumindex 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:fD57ERR4JtEqsWbgithub.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/Gfe8XTGXQJgLYQ65oGKMfPivb2EASLUSMSWgo.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=