Merge remote-tracking branch 'origin/benvin/remote-head-route' into benvin/nuget-followups

- set Cache-Control no-store and Vary on rewritten responses
- accept only http/https X-Forwarded-Proto
- reject invalid Host headers and JSON-escape the injected base URL
- route remote HEAD and serve rewritten HEAD via the GET path
- classify snupkg, readme and icon as immutable

README.md

@@ -280,20 +280,6 @@ content-addressable store (deduplicated by digest, reaped by GC once
 unreferenced); tags are mutable references and re-pushing a tag moves it. Blob
 uploads support both the monolithic and chunked (`POST`/`PATCH`/`PUT`) flows.
 
-### Local cargo registry
-
-A local `cargo` repo is a private crate registry: it serves the sparse index and
-the Web API publish, yank and unyank endpoints, so `cargo publish` works against
-it directly.
-
-```toml
-[registries.<repo>]
-index = "sparse+https://artifactapi.k8s.syd1.au.unkin.net/api/v1/local/<repo>/"
-```
-
-cargo requires a token for publish/yank (`CARGO_REGISTRIES_<REPO>_TOKEN`); like
-other local repos, artifactapi does not check it.
-
 ## Access Control
 
 | Field | Default | Behaviour |

e2e-docker/README.md

@@ -27,8 +27,7 @@ already-running stack.
   mock upstream: first fetch `X-Artifact-Source: remote`, second `cache`, bytes
   verified against the origin fixture.
 - **Local uploads** — generic (upload/download), pypi (wheel + generated `simple/`
-  index), rpm (real package + **automatic repodata** generation), cargo (publish,
-  sparse index, download, yank).
+  index), rpm (real package + **automatic repodata** generation).
 - **Virtual repositories** — pypi simple-index merge and helm `index.yaml` merge
   across two members.
 - **Mirrorlist** — an rpm remote with a `mirrorlist` of extra upstream mirrors

e2e-docker/cargo_local_test.go

@@ -1,66 +0,0 @@
-//go:build dockere2e
-
-package e2edocker
-
-import (
-	"bytes"
-	"encoding/binary"
-	"net/http"
-	"strings"
-	"testing"
-)
-
-// TestLocalCargoRegistry publishes through the cargo Web API, then reads the
-// sparse index, downloads the crate and yanks it.
-func TestLocalCargoRegistry(t *testing.T) {
-	createRepo(t, `{"name":"local-cargo","package_type":"cargo","repo_type":"local"}`)
-	defer deleteRepo(t, "local-cargo")
-	base := api("/api/v1/local/local-cargo")
-
-	meta := `{"name":"e2e-crate","vers":"0.1.0","deps":[],"features":{}}`
-	crate := []byte("e2e crate bytes")
-	publish := func(meta string) *http.Response {
-		var body []byte
-		body = binary.LittleEndian.AppendUint32(body, uint32(len(meta)))
-		body = append(body, meta...)
-		body = binary.LittleEndian.AppendUint32(body, uint32(len(crate)))
-		body = append(body, crate...)
-		resp, _ := doRequest(t, http.MethodPut, base+"/api/v1/crates/new", body, "application/octet-stream")
-		return resp
-	}
-
-	if resp := publish(meta); resp.StatusCode != http.StatusOK {
-		t.Fatalf("publish: status %d", resp.StatusCode)
-	}
-	if resp := publish(meta); resp.StatusCode != http.StatusConflict {
-		t.Fatalf("republish: status %d, want 409", resp.StatusCode)
-	}
-	if resp := publish(`{"name":"e2e-crate","vers":"0.1.0+other","deps":[],"features":{}}`); resp.StatusCode != http.StatusConflict {
-		t.Fatalf("build-metadata republish: status %d, want 409", resp.StatusCode)
-	}
-	if resp := publish(`{"name":"E2E_crate","vers":"0.2.0","deps":[],"features":{}}`); resp.StatusCode != http.StatusBadRequest {
-		t.Fatalf("name collision publish: status %d, want 400", resp.StatusCode)
-	}
-
-	resp, b := doRequest(t, http.MethodGet, base+"/config.json", nil, "")
-	if resp.StatusCode != http.StatusOK || !strings.Contains(string(b), `"api":"`) {
-		t.Fatalf("config.json: status %d: %s", resp.StatusCode, b)
-	}
-
-	resp, b = doRequest(t, http.MethodGet, base+"/e2/e-/e2e-crate", nil, "")
-	if resp.StatusCode != http.StatusOK || !strings.Contains(string(b), `"cksum":"`) || !strings.Contains(string(b), `"yanked":false`) {
-		t.Fatalf("index: status %d: %s", resp.StatusCode, b)
-	}
-
-	resp, b = doRequest(t, http.MethodGet, base+"/crates/e2e-crate/e2e-crate-0.1.0.crate", nil, "")
-	if resp.StatusCode != http.StatusOK || !bytes.Equal(b, crate) {
-		t.Fatalf("download: status %d", resp.StatusCode)
-	}
-
-	if resp, b := doRequest(t, http.MethodDelete, base+"/api/v1/crates/e2e-crate/0.1.0/yank", nil, ""); resp.StatusCode != http.StatusOK {
-		t.Fatalf("yank: status %d: %s", resp.StatusCode, b)
-	}
-	if _, b := doRequest(t, http.MethodGet, base+"/e2/e-/e2e-crate", nil, ""); !strings.Contains(string(b), `"yanked":true`) {
-		t.Fatalf("index after yank: %s", b)
-	}
-}

e2e/head_test.go

@@ -0,0 +1,182 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"git.unkin.net/unkin/artifactapi/internal/testsupport"
+)
+
+// assertHeadMatchesGet checks HEAD returns GET's status, type and length with no body.
+func assertHeadMatchesGet(t *testing.T, url string) {
+	t.Helper()
+	get, err := http.Get(url)
+	if err != nil {
+		t.Fatalf("GET: %v", err)
+	}
+	body, _ := io.ReadAll(get.Body)
+	get.Body.Close()
+	if get.StatusCode != http.StatusOK {
+		t.Fatalf("GET %s: %d %s", url, get.StatusCode, body)
+	}
+
+	head, err := http.Head(url)
+	if err != nil {
+		t.Fatalf("HEAD: %v", err)
+	}
+	hb, _ := io.ReadAll(head.Body)
+	head.Body.Close()
+	if head.StatusCode != http.StatusOK {
+		t.Fatalf("HEAD %s: got %d, want 200", url, head.StatusCode)
+	}
+	if len(hb) != 0 {
+		t.Errorf("HEAD returned a %d-byte body", len(hb))
+	}
+	for _, h := range []string{"Content-Type", "Cache-Control", "Vary"} {
+		if head.Header.Get(h) != get.Header.Get(h) {
+			t.Errorf("HEAD %s %q, GET %q", h, head.Header.Get(h), get.Header.Get(h))
+		}
+	}
+	if head.ContentLength != int64(len(body)) {
+		t.Errorf("HEAD Content-Length %d, GET body %d bytes", head.ContentLength, len(body))
+	}
+}
+
+func TestProxyHeadNuGetRewritten(t *testing.T) {
+	var upstream *httptest.Server
+	upstream = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]any{"version": "3.0.0", "resources": []map[string]string{
+			{"@id": upstream.URL + "/v3-flatcontainer/", "@type": "PackageBaseAddress/3.0.0"},
+		}})
+	}))
+	defer upstream.Close()
+
+	createRemote(t, mustFormat(`{"name": "head-nuget", "package_type": "nuget", "base_url": %q}`, upstream.URL+"/v3/index.json"))
+	defer deleteRemote(t, "head-nuget")
+
+	url := apiURL("/api/v1/remote/head-nuget/index.json")
+	assertHeadMatchesGet(t, url)
+
+	req, _ := http.NewRequest(http.MethodHead, url, nil)
+	req.Host = "evil.example:"
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Errorf("HEAD with invalid Host: got %d, want 400", resp.StatusCode)
+	}
+}
+
+func TestProxyHeadGitHubRPMRepodata(t *testing.T) {
+	rpm := testsupport.MinimalRPM("demo", "1.2", "3", "x86_64")
+	var gh *httptest.Server
+	mux := http.NewServeMux()
+	mux.HandleFunc("/repos/acme/tools/releases", func(w http.ResponseWriter, r *http.Request) {
+		if p := r.URL.Query().Get("page"); p != "" && p != "1" {
+			w.Write([]byte("[]"))
+			return
+		}
+		json.NewEncoder(w).Encode([]map[string]any{{"tag_name": "v1.2-3", "assets": []map[string]any{{
+			"name":                 "demo-1.2-3.x86_64.rpm",
+			"size":                 len(rpm),
+			"browser_download_url": gh.URL + "/acme/tools/releases/download/v1.2-3/demo-1.2-3.x86_64.rpm",
+		}}}})
+	})
+	mux.HandleFunc("/acme/tools/releases/download/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Length", strconv.Itoa(len(rpm)))
+		w.Write(rpm)
+	})
+	gh = httptest.NewServer(mux)
+	defer gh.Close()
+
+	createRemote(t, mustFormat(`{"name": "head-ghrpm", "package_type": "github_rpm", "base_url": %q, "releases_remote": "github"}`, gh.URL+"/repos/acme/tools"))
+	defer deleteRemote(t, "head-ghrpm")
+
+	url := apiURL("/api/v1/remote/head-ghrpm/repodata/repomd.xml")
+	deadline := time.Now().Add(30 * time.Second)
+	for {
+		if _, status := getBody(t, url); status == http.StatusOK || time.Now().After(deadline) {
+			break
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+	assertHeadMatchesGet(t, url)
+}
+
+func TestProxyHeadNpmUncachedPackument(t *testing.T) {
+	const abbreviated = "application/vnd.npm.install-v1+json"
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		doc := map[string]any{"name": "left-pad", "versions": map[string]any{"1.3.0": map[string]any{}}}
+		if r.Header.Get("Accept") != abbreviated {
+			doc["readme"] = strings.Repeat("full packument ", 200)
+		}
+		json.NewEncoder(w).Encode(doc)
+	}))
+	defer upstream.Close()
+
+	createRemote(t, mustFormat(`{"name": "head-npm", "package_type": "npm", "base_url": %q}`, upstream.URL))
+	defer deleteRemote(t, "head-npm")
+
+	url := apiURL("/api/v1/remote/head-npm/left-pad")
+	do := func(method string) (*http.Response, []byte) {
+		req, _ := http.NewRequest(method, url, nil)
+		req.Header.Set("Accept", abbreviated)
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			t.Fatalf("%s: %v", method, err)
+		}
+		defer resp.Body.Close()
+		b, _ := io.ReadAll(resp.Body)
+		return resp, b
+	}
+	head, _ := do(http.MethodHead)
+	get, body := do(http.MethodGet)
+	if head.StatusCode != http.StatusOK || get.StatusCode != http.StatusOK {
+		t.Fatalf("HEAD %d, GET %d", head.StatusCode, get.StatusCode)
+	}
+	if head.ContentLength != int64(len(body)) {
+		t.Errorf("uncached HEAD Content-Length %d, GET body %d bytes", head.ContentLength, len(body))
+	}
+}
+
+func TestProxyHeadNonRewritingUsesUpstreamHead(t *testing.T) {
+	methods := make(chan string, 4)
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		methods <- r.Method
+		w.Header().Set("Content-Type", "text/xml")
+		w.Write([]byte("<repomd/>"))
+	}))
+	defer upstream.Close()
+
+	createRemote(t, mustFormat(`{"name": "head-rpm", "package_type": "rpm", "base_url": %q}`, upstream.URL))
+	defer deleteRemote(t, "head-rpm")
+
+	resp, err := http.Head(apiURL("/api/v1/remote/head-rpm/repodata/repomd.xml"))
+	if err != nil {
+		t.Fatalf("HEAD: %v", err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusOK || resp.Header.Get("X-Artifact-Source") != "remote" {
+		t.Fatalf("HEAD %d source %q", resp.StatusCode, resp.Header.Get("X-Artifact-Source"))
+	}
+	close(methods)
+	var seen []string
+	for m := range methods {
+		seen = append(seen, m)
+	}
+	if len(seen) != 1 || seen[0] != http.MethodHead {
+		t.Errorf("upstream saw %v, want a single HEAD", seen)
+	}
+}

e2e/scheme_test.go

@@ -0,0 +1,59 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func getForwardedHTTPS(t *testing.T, url string) *http.Response {
+	t.Helper()
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	req.Header.Set("X-Forwarded-Proto", "https")
+	client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("GET %s: %v", url, err)
+	}
+	return resp
+}
+
+func TestForwardedProtoCargoConfig(t *testing.T) {
+	createRemote(t, `{"name": "scheme-cargo", "package_type": "cargo", "base_url": "https://index.crates.io"}`)
+	defer deleteRemote(t, "scheme-cargo")
+
+	resp := getForwardedHTTPS(t, apiURL("/api/v1/remote/scheme-cargo/config.json"))
+	defer resp.Body.Close()
+	var cfg map[string]string
+	if err := json.NewDecoder(resp.Body).Decode(&cfg); err != nil {
+		t.Fatal(err)
+	}
+	if want := "https://" + strings.TrimPrefix(baseURL, "http://") + "/api/v1/remote/scheme-cargo/"; !strings.HasPrefix(cfg["dl"], want) {
+		t.Errorf("dl = %q, want prefix %q", cfg["dl"], want)
+	}
+}
+
+func TestForwardedProtoVirtualRedirect(t *testing.T) {
+	createRemote(t, `{"name": "scheme-rpm", "package_type": "rpm", "base_url": "https://rpm.example.com"}`)
+	defer deleteRemote(t, "scheme-rpm")
+	resp, err := http.Post(apiURL("/api/v2/virtuals"), "application/json",
+		strings.NewReader(`{"name": "scheme-virt", "package_type": "rpm", "members": ["scheme-rpm"]}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("create virtual: status %d", resp.StatusCode)
+	}
+	defer deleteRequest(t, apiURL("/api/v2/virtuals/scheme-virt"))
+
+	resp = getForwardedHTTPS(t, apiURL("/api/v1/virtual/scheme-virt/scheme-rpm/Packages/a.rpm"))
+	resp.Body.Close()
+	loc := resp.Header.Get("Location")
+	if want := "https://" + strings.TrimPrefix(baseURL, "http://") + "/api/v1/remote/scheme-rpm/Packages/a.rpm"; resp.StatusCode != http.StatusFound || loc != want {
+		t.Errorf("redirect = %d %q, want 302 %q", resp.StatusCode, loc, want)
+	}
+}

internal/api/terraform/registry.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/go-chi/chi/v5"
 
+	v1 "git.unkin.net/unkin/artifactapi/internal/api/v1"
 	"git.unkin.net/unkin/artifactapi/internal/database"
 	tfprov "git.unkin.net/unkin/artifactapi/internal/provider/terraform"
 	"git.unkin.net/unkin/artifactapi/internal/tfsign"
@@ -290,12 +291,5 @@ func writeJSON(w http.ResponseWriter, v any) {
 }
 
 func baseURL(r *http.Request) string {
-	scheme := "http"
-	if r.TLS != nil {
-		scheme = "https"
-	}
-	if fwd := r.Header.Get("X-Forwarded-Proto"); fwd != "" {
-		scheme = fwd
-	}
-	return scheme + "://" + r.Host
+	return v1.Scheme(r) + "://" + r.Host
 }

internal/api/v1/cargo.go

@@ -1,139 +0,0 @@
-package v1
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"net/http"
-
-	"github.com/go-chi/chi/v5"
-
-	"git.unkin.net/unkin/artifactapi/internal/database"
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-	"git.unkin.net/unkin/artifactapi/internal/provider/cargo"
-	"git.unkin.net/unkin/artifactapi/pkg/models"
-)
-
-// This file implements the cargo registry Web API (publish, yank, unyank) for
-// local cargo repositories. config.json points api at /api/v1/local/<repo>, so
-// cargo appends its own /api/v1/crates/... below that.
-
-const maxCratePublish = 64 << 20
-
-func (h *ProxyHandler) localCargoRemote(r *http.Request) (*models.Remote, bool) {
-	remote, err := h.db.GetRemote(r.Context(), chi.URLParam(r, "localName"))
-	if err != nil {
-		return nil, false
-	}
-	return remote, remote.RepoType == models.RepoTypeLocal && remote.PackageType == models.PackageCargo
-}
-
-func cargoError(w http.ResponseWriter, status int, format string, args ...any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(map[string]any{
-		"errors": []map[string]string{{"detail": fmt.Sprintf(format, args...)}},
-	})
-}
-
-func cargoOK(w http.ResponseWriter, v any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(v)
-}
-
-func (h *ProxyHandler) cargoPublish(w http.ResponseWriter, r *http.Request) {
-	remote, ok := h.localCargoRemote(r)
-	if !ok {
-		cargoError(w, http.StatusNotFound, "no local cargo registry %q", chi.URLParam(r, "localName"))
-		return
-	}
-	ctx := r.Context()
-
-	body, err := io.ReadAll(io.LimitReader(r.Body, maxCratePublish+1))
-	if err != nil {
-		cargoError(w, http.StatusBadRequest, "read body: %v", err)
-		return
-	}
-	if len(body) > maxCratePublish {
-		cargoError(w, http.StatusRequestEntityTooLarge, "publish body exceeds %d bytes", maxCratePublish)
-		return
-	}
-	meta, crate, err := cargo.ParsePublish(body)
-	if err != nil {
-		cargoError(w, http.StatusBadRequest, "%v", err)
-		return
-	}
-	line, err := cargo.NewIndexLine(meta, crate)
-	if err != nil {
-		cargoError(w, http.StatusBadRequest, "%v", err)
-		return
-	}
-
-	lineJSON, err := json.Marshal(line)
-	if err != nil {
-		cargoError(w, http.StatusInternalServerError, "%v", err)
-		return
-	}
-
-	path := cargo.CratePath(meta.Name, meta.Vers)
-	result, err := h.cas.Store(ctx, bytes.NewReader(crate), "application/gzip")
-	if err != nil {
-		cargoError(w, http.StatusInternalServerError, "store failed: %v", err)
-		return
-	}
-	if err := h.db.UpsertBlob(ctx, result.ContentHash, result.S3Key, result.SizeBytes, "application/gzip"); err != nil {
-		cargoError(w, http.StatusInternalServerError, "record blob: %v", err)
-		return
-	}
-	if err := h.db.CreateLocalFile(ctx, remote.Name, path, result.ContentHash); err != nil {
-		if errors.Is(err, database.ErrAlreadyExists) {
-			cargoError(w, http.StatusConflict, "crate version `%s@%s` already exists", meta.Name, meta.Vers)
-			return
-		}
-		cargoError(w, http.StatusInternalServerError, "record file: %v", err)
-		return
-	}
-	entry := &provider.CargoIndexEntry{RepoName: remote.Name, FilePath: path, Name: meta.Name, Version: meta.Vers, Line: string(lineJSON)}
-	if err := h.db.InsertCargoIndexEntry(ctx, entry); err != nil {
-		// Drop the file so a retry is not rejected as a duplicate.
-		_ = h.db.DeleteLocalFile(ctx, remote.Name, path)
-		switch {
-		case errors.Is(err, database.ErrCargoNameTaken):
-			cargoError(w, http.StatusBadRequest, "%v", err)
-		case errors.Is(err, database.ErrAlreadyExists):
-			cargoError(w, http.StatusConflict, "crate version `%s@%s` already exists", meta.Name, meta.Vers)
-		default:
-			cargoError(w, http.StatusInternalServerError, "record index: %v", err)
-		}
-		return
-	}
-
-	slog.Info("cargo: published", "repo", remote.Name, "crate", meta.Name, "version", meta.Vers)
-	cargoOK(w, map[string]any{"warnings": map[string][]string{"invalid_categories": {}, "invalid_badges": {}, "other": {}}})
-}
-
-func (h *ProxyHandler) cargoYank(yanked bool) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		remote, ok := h.localCargoRemote(r)
-		if !ok {
-			cargoError(w, http.StatusNotFound, "no local cargo registry %q", chi.URLParam(r, "localName"))
-			return
-		}
-		name, version := chi.URLParam(r, "crate"), chi.URLParam(r, "version")
-		found, err := h.db.SetCargoYanked(r.Context(), remote.Name, name, version, yanked)
-		if err != nil {
-			cargoError(w, http.StatusInternalServerError, "%v", err)
-			return
-		}
-		if !found {
-			cargoError(w, http.StatusNotFound, "crate version `%s@%s` not found", name, version)
-			return
-		}
-		slog.Info("cargo: yank updated", "repo", remote.Name, "crate", name, "version", version, "yanked", yanked)
-		cargoOK(w, map[string]bool{"ok": true})
-	}
-}

internal/api/v1/proxy.go

@@ -6,7 +6,10 @@ import (
 	"fmt"
 	"io"
 	"log/slog"
+	"net"
 	"net/http"
+	"strconv"
+	"strings"
 
 	"github.com/go-chi/chi/v5"
 
@@ -16,6 +19,7 @@ import (
 	"git.unkin.net/unkin/artifactapi/internal/proxy"
 	"git.unkin.net/unkin/artifactapi/internal/storage"
 	"git.unkin.net/unkin/artifactapi/internal/virtual"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
 )
 
 type ProxyHandler struct {
@@ -41,10 +45,8 @@ func NewProxyHandler(engine *proxy.Engine, virtualEngine *virtual.Engine, db *da
 func (h *ProxyHandler) Routes() chi.Router {
 	r := chi.NewRouter()
 	r.Get("/remote/{remoteName}/*", h.handleProxy)
+	r.Head("/remote/{remoteName}/*", h.handleProxyHead)
 	r.Get("/local/{localName}/*", h.handleLocal)
-	r.Put("/local/{localName}/api/v1/crates/new", h.cargoPublish)
-	r.Delete("/local/{localName}/api/v1/crates/{crate}/{version}/yank", h.cargoYank(true))
-	r.Put("/local/{localName}/api/v1/crates/{crate}/{version}/unyank", h.cargoYank(false))
 	r.Get("/virtual/{virtualName}/*", h.handleVirtual)
 	return r
 }
@@ -71,31 +73,43 @@ func (h *ProxyHandler) handleDockerPing(w http.ResponseWriter, r *http.Request)
 	w.WriteHeader(http.StatusOK)
 }
 
-func (h *ProxyHandler) handleProxy(w http.ResponseWriter, r *http.Request) {
+// remoteFor resolves the remote and provider named in the request, writing the
+// error response itself when either is missing.
+func (h *ProxyHandler) remoteFor(w http.ResponseWriter, r *http.Request) (*models.Remote, provider.Provider, bool) {
 	remoteName := chi.URLParam(r, "remoteName")
-	path := chi.URLParam(r, "*")
-
 	remote, err := h.db.GetRemote(r.Context(), remoteName)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("remote %q not found", remoteName), http.StatusNotFound)
-		return
+		return nil, nil, false
 	}
-
 	prov, err := provider.Get(remote.PackageType)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("no provider for %q", remote.PackageType), http.StatusInternalServerError)
+		return nil, nil, false
+	}
+	return remote, prov, true
+}
+
+// serveRemote lets metadata-only remotes (e.g. github_rpm) synthesize their own
+// responses and redirect package downloads instead of proxying bytes.
+func (h *ProxyHandler) serveRemote(w http.ResponseWriter, r *http.Request, remote *models.Remote, prov provider.Provider, path string) bool {
+	rs, ok := prov.(provider.RemoteServer)
+	return ok && rs.ServeRemote(w, r, *remote, path, fmt.Sprintf("%s://%s", Scheme(r), r.Host), h.db)
+}
+
+func (h *ProxyHandler) handleProxy(w http.ResponseWriter, r *http.Request) {
+	remote, prov, ok := h.remoteFor(w, r)
+	if !ok {
 		return
 	}
-
-	// Metadata-only remotes (e.g. github_rpm) synthesize their own responses and
-	// redirect package downloads to a backend remote instead of proxying bytes.
-	if rs, ok := prov.(provider.RemoteServer); ok {
-		proxyBaseURL := fmt.Sprintf("%s://%s", scheme(r), r.Host)
-		if rs.ServeRemote(w, r, *remote, path, proxyBaseURL, h.db) {
-			return
-		}
+	path := chi.URLParam(r, "*")
+	if h.serveRemote(w, r, remote, prov, path) {
+		return
 	}
+	h.serveFetch(w, r, remote, prov, path)
+}
 
+func (h *ProxyHandler) serveFetch(w http.ResponseWriter, r *http.Request, remote *models.Remote, prov provider.Provider, path string) {
 	result, err := h.engine.Fetch(r.Context(), *remote, path, prov, r.Header)
 	if err != nil {
 		var proxyErr *proxy.ProxyError
@@ -103,7 +117,7 @@ func (h *ProxyHandler) handleProxy(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, proxyErr.Message, proxyErr.Status)
 			return
 		}
-		slog.Error("proxy fetch failed", "remote", remoteName, "path", path, "error", err)
+		slog.Error("proxy fetch failed", "remote", remote.Name, "path", path, "error", err)
 		http.Error(w, "bad gateway", http.StatusBadGateway)
 		return
 	}
@@ -111,37 +125,43 @@ func (h *ProxyHandler) handleProxy(w http.ResponseWriter, r *http.Request) {
 
 	var body io.Reader = result.Reader
 	if sr, ok := prov.(provider.ServeRewriter); ok && prov.Classify(path) == provider.Mutable {
-		raw, err := io.ReadAll(result.Reader)
-		if err != nil {
-			http.Error(w, "bad gateway", http.StatusBadGateway)
+		raw, ok := rewriteServed(w, r, sr, *remote, result.Reader)
+		if !ok {
 			return
 		}
-		raw = sr.RewriteServed(raw, *remote, fmt.Sprintf("%s://%s", scheme(r), r.Host))
 		body, result.Size = bytes.NewReader(raw), int64(len(raw))
 	}
 
 	w.Header().Set("Content-Type", result.ContentType)
 	w.Header().Set("X-Artifact-Source", result.Source)
 	if result.Size > 0 {
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", result.Size))
 		w.Header().Set("X-Artifact-Size", fmt.Sprintf("%d", result.Size))
 	}
 	w.WriteHeader(http.StatusOK)
 	io.Copy(w, body)
 }
 
-func (h *ProxyHandler) handleProxyHead(w http.ResponseWriter, r *http.Request) {
-	remoteName := chi.URLParam(r, "remoteName")
-	path := chi.URLParam(r, "*")
+func rewritesMutable(prov provider.Provider, path string) bool {
+	_, sr := prov.(provider.ServeRewriter)
+	_, rr := prov.(provider.ResponseRewriter)
+	return (sr || rr) && prov.Classify(path) == provider.Mutable
+}
 
-	remote, err := h.db.GetRemote(r.Context(), remoteName)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("remote %q not found", remoteName), http.StatusNotFound)
+// handleProxyHead answers HEAD like GET without a body. Responses a provider
+// synthesizes or rewrites per request go through the GET path so their headers
+// match; everything else is answered from store metadata or an upstream HEAD.
+func (h *ProxyHandler) handleProxyHead(w http.ResponseWriter, r *http.Request) {
+	remote, prov, ok := h.remoteFor(w, r)
+	if !ok {
 		return
 	}
-
-	prov, err := provider.Get(remote.PackageType)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("no provider for %q", remote.PackageType), http.StatusInternalServerError)
+	path := chi.URLParam(r, "*")
+	if h.serveRemote(w, r, remote, prov, path) {
+		return
+	}
+	if rewritesMutable(prov, path) {
+		h.serveFetch(w, r, remote, prov, path)
 		return
 	}
 
@@ -152,7 +172,7 @@ func (h *ProxyHandler) handleProxyHead(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, proxyErr.Message, proxyErr.Status)
 			return
 		}
-		slog.Error("proxy head failed", "remote", remoteName, "path", path, "error", err)
+		slog.Error("proxy head failed", "remote", remote.Name, "path", path, "error", err)
 		http.Error(w, "bad gateway", http.StatusBadGateway)
 		return
 	}
@@ -175,7 +195,7 @@ func (h *ProxyHandler) handleVirtual(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	proxyBaseURL := fmt.Sprintf("%s://%s", scheme(r), r.Host)
+	proxyBaseURL := fmt.Sprintf("%s://%s", Scheme(r), r.Host)
 
 	loc, ok, err := h.virtualEngine.MemberRedirect(r.Context(), *virt, path, r.URL.RawQuery, proxyBaseURL)
 	if err != nil {
@@ -252,12 +272,68 @@ func (h *ProxyHandler) serveLocalFile(w http.ResponseWriter, r *http.Request, re
 	io.Copy(w, reader)
 }
 
-func scheme(r *http.Request) string {
+// Scheme returns the client-facing scheme: TLS, else the first
+// X-Forwarded-Proto value when it is http or https, else http.
+func Scheme(r *http.Request) string {
 	if r.TLS != nil {
 		return "https"
 	}
-	if fwd := r.Header.Get("X-Forwarded-Proto"); fwd != "" {
+	fwd, _, _ := strings.Cut(r.Header.Get("X-Forwarded-Proto"), ",")
+	if fwd = strings.ToLower(strings.TrimSpace(fwd)); fwd == "https" {
 		return fwd
 	}
 	return "http"
 }
+
+// rewriteServed rewrites a cached body for the requesting host and marks the
+// response uncacheable by shared caches, since it varies per Host.
+func rewriteServed(w http.ResponseWriter, r *http.Request, sr provider.ServeRewriter, remote models.Remote, src io.Reader) ([]byte, bool) {
+	if !validHost(r.Host) {
+		http.Error(w, "invalid host header", http.StatusBadRequest)
+		return nil, false
+	}
+	raw, err := io.ReadAll(src)
+	if err != nil {
+		http.Error(w, "bad gateway", http.StatusBadGateway)
+		return nil, false
+	}
+	raw = sr.RewriteServed(raw, remote, fmt.Sprintf("%s://%s", Scheme(r), r.Host))
+	w.Header().Set("Cache-Control", "no-store")
+	w.Header().Set("Vary", "Host, X-Forwarded-Proto")
+	w.Header().Set("Content-Length", strconv.Itoa(len(raw)))
+	return raw, true
+}
+
+// validHost accepts host[:port] where host is a DNS name or IP literal.
+func validHost(hostport string) bool {
+	host, port := hostport, ""
+	if h, p, err := net.SplitHostPort(hostport); err == nil {
+		if p == "" {
+			return false
+		}
+		host, port = h, p
+	} else if strings.HasPrefix(hostport, "[") {
+		return strings.HasSuffix(hostport, "]") && net.ParseIP(hostport[1:len(hostport)-1]) != nil
+	}
+	if port != "" {
+		if n, err := strconv.Atoi(port); err != nil || n < 1 || n > 65535 {
+			return false
+		}
+	}
+	if net.ParseIP(host) != nil {
+		return true
+	}
+	if strings.HasPrefix(hostport, "[") {
+		return false
+	}
+	if host == "" || len(host) > 253 {
+		return false
+	}
+	for _, label := range strings.Split(strings.TrimSuffix(host, "."), ".") {
+		if label == "" || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' ||
+			strings.Trim(strings.ToLower(label), "abcdefghijklmnopqrstuvwxyz0123456789-_") != "" {
+			return false
+		}
+	}
+	return true
+}

internal/api/v1/rewrite_test.go

@@ -0,0 +1,74 @@
+package v1
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.unkin.net/unkin/artifactapi/internal/provider/nuget"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
+)
+
+func TestValidHost(t *testing.T) {
+	for _, h := range []string{"aa.example", "aa.example:8443", "artifactapi.k8s.syd1.au.unkin.net", "10.0.0.1:80", "[::1]:8080", "[::1]", "::1", "localhost", "my_host.local"} {
+		if !validHost(h) {
+			t.Errorf("validHost(%q) = false, want true", h)
+		}
+	}
+	for _, h := range []string{"", "evil\".example", "a b", "aa.example:0", "aa.example:99999", "aa.example:x", "aa.example:", ":8080", "-bad.example", "a..b", "[::1", "[nope]:80", "a/b", "a<script>", strings.Repeat("a", 64) + ".example"} {
+		if validHost(h) {
+			t.Errorf("validHost(%q) = true, want false", h)
+		}
+	}
+}
+
+var nugetOrg = models.Remote{Name: "nuget-org", BaseURL: "https://api.nuget.org/v3/index.json"}
+
+const serviceIndex = `{"resources":[{"@id":"https://api.nuget.org/v3-flatcontainer/"}]}`
+
+func rewrite(t *testing.T, host, proto string) (*httptest.ResponseRecorder, string, bool) {
+	t.Helper()
+	r := httptest.NewRequest(http.MethodGet, "/api/v1/remote/nuget-org/index.json", nil)
+	r.Host = host
+	if proto != "" {
+		r.Header.Set("X-Forwarded-Proto", proto)
+	}
+	w := httptest.NewRecorder()
+	raw, ok := rewriteServed(w, r, &nuget.Provider{}, nugetOrg, strings.NewReader(serviceIndex))
+	return w, string(raw), ok
+}
+
+func TestRewriteServedHeaders(t *testing.T) {
+	w, body, ok := rewrite(t, "aa.example:8443", "https")
+	if !ok {
+		t.Fatal("valid request rejected")
+	}
+	if want := `{"resources":[{"@id":"https://aa.example:8443/api/v1/remote/nuget-org/v3-flatcontainer/"}]}`; body != want {
+		t.Errorf("body = %s, want %s", body, want)
+	}
+	if got := w.Header().Get("Cache-Control"); got != "no-store" {
+		t.Errorf("Cache-Control = %q, want no-store", got)
+	}
+	if got := w.Header().Get("Vary"); got != "Host, X-Forwarded-Proto" {
+		t.Errorf("Vary = %q", got)
+	}
+	if got := w.Header().Get("Content-Length"); got != "91" || len(body) != 91 {
+		t.Errorf("Content-Length = %q, body len %d", got, len(body))
+	}
+}
+
+func TestRewriteServedIgnoresBogusProto(t *testing.T) {
+	_, plain, _ := rewrite(t, "aa.example", "")
+	_, bogus, _ := rewrite(t, "aa.example", "javascript")
+	if bogus != plain || !strings.Contains(bogus, `"http://aa.example/`) {
+		t.Errorf("bogus X-Forwarded-Proto changed the body: %s", bogus)
+	}
+}
+
+func TestRewriteServedRejectsInvalidHost(t *testing.T) {
+	w, _, ok := rewrite(t, `evil"},{"x":"`, "")
+	if ok || w.Code != http.StatusBadRequest {
+		t.Errorf("invalid host: ok=%v code=%d, want rejected with 400", ok, w.Code)
+	}
+}

internal/api/v1/routes_test.go

@@ -0,0 +1,41 @@
+package v1
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+
+	"git.unkin.net/unkin/artifactapi/internal/provider"
+	"git.unkin.net/unkin/artifactapi/internal/provider/npm"
+	"git.unkin.net/unkin/artifactapi/internal/provider/nuget"
+	"git.unkin.net/unkin/artifactapi/internal/provider/rpm"
+)
+
+func TestRoutesRemoteHead(t *testing.T) {
+	r := (&ProxyHandler{}).Routes()
+	for _, m := range []string{http.MethodGet, http.MethodHead} {
+		if !r.Match(chi.NewRouteContext(), m, "/remote/myremote/some/path") {
+			t.Errorf("%s /remote/myremote/some/path not routed", m)
+		}
+	}
+}
+
+func TestRewritesMutable(t *testing.T) {
+	tests := []struct {
+		name string
+		prov provider.Provider
+		path string
+		want bool
+	}{
+		{"npm packument", &npm.Provider{}, "left-pad", true},
+		{"npm tarball", &npm.Provider{}, "left-pad/-/left-pad-1.3.0.tgz", false},
+		{"nuget index", &nuget.Provider{}, "index.json", true},
+		{"rpm repodata", &rpm.Provider{}, "repodata/repomd.xml", false},
+	}
+	for _, tc := range tests {
+		if got := rewritesMutable(tc.prov, tc.path); got != tc.want {
+			t.Errorf("%s: rewritesMutable = %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}

internal/api/v1/scheme_test.go

@@ -7,14 +7,28 @@ import (
 )
 
 func TestScheme(t *testing.T) {
-	if got := scheme(&http.Request{TLS: &tls.ConnectionState{}}); got != "https" {
+	if got := Scheme(&http.Request{TLS: &tls.ConnectionState{}}); got != "https" {
 		t.Errorf("TLS request scheme = %q, want https", got)
 	}
 	r := &http.Request{Header: http.Header{"X-Forwarded-Proto": {"https"}}}
-	if got := scheme(r); got != "https" {
+	if got := Scheme(r); got != "https" {
 		t.Errorf("X-Forwarded-Proto scheme = %q, want https", got)
 	}
-	if got := scheme(&http.Request{Header: http.Header{}}); got != "http" {
+	for fwd, want := range map[string]string{
+		"https, http": "https",
+		"http, https": "http",
+		"HTTPS":       "https",
+		" https ":     "https",
+		"javascript":  "http",
+		"ftp":         "http",
+		"https;evil":  "http",
+	} {
+		r := &http.Request{Header: http.Header{"X-Forwarded-Proto": {fwd}}}
+		if got := Scheme(r); got != want {
+			t.Errorf("X-Forwarded-Proto %q scheme = %q, want %s", fwd, got, want)
+		}
+	}
+	if got := Scheme(&http.Request{Header: http.Header{}}); got != "http" {
 		t.Errorf("default scheme = %q, want http", got)
 	}
 }

internal/database/cargo_index.go

@@ -1,111 +0,0 @@
-package database
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/jackc/pgx/v5/pgconn"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-var ErrCargoNameTaken = errors.New("crate name already taken")
-
-func cargoNormName(name string) string {
-	return strings.ReplaceAll(strings.ToLower(name), "-", "_")
-}
-
-// InsertCargoIndexEntry rejects a name that differs from an existing crate only
-// by case or -/_ (ErrCargoNameTaken) and a version equal up to build metadata
-// (ErrAlreadyExists). A per-crate advisory lock serialises concurrent publishes.
-func (db *DB) InsertCargoIndexEntry(ctx context.Context, e *provider.CargoIndexEntry) error {
-	tx, err := db.Pool.Begin(ctx)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback(ctx) }()
-
-	norm := cargoNormName(e.Name)
-	if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock(hashtext('cargo:' || $1 || '/' || $2))`, e.RepoName, norm); err != nil {
-		return err
-	}
-	rows, err := tx.Query(ctx, `
-		SELECT name, version FROM cargo_index
-		WHERE repo_name = $1 AND replace(lower(name), '-', '_') = $2
-	`, e.RepoName, norm)
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-	base, _, _ := strings.Cut(e.Version, "+")
-	for rows.Next() {
-		var name, version string
-		if err := rows.Scan(&name, &version); err != nil {
-			return err
-		}
-		if name != e.Name {
-			return fmt.Errorf("%w: %q exists as %q", ErrCargoNameTaken, e.Name, name)
-		}
-		if v, _, _ := strings.Cut(version, "+"); v == base {
-			return fmt.Errorf("%w: %s@%s", ErrAlreadyExists, name, version)
-		}
-	}
-	if err := rows.Err(); err != nil {
-		return err
-	}
-	rows.Close()
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO cargo_index (repo_name, file_path, name, version, line, yanked)
-		VALUES ($1, $2, $3, $4, $5, $6)
-	`, e.RepoName, e.FilePath, e.Name, e.Version, e.Line, e.Yanked); err != nil {
-		var pgErr *pgconn.PgError
-		if errors.As(err, &pgErr) && pgErr.Code == "23505" {
-			return fmt.Errorf("%w: %s@%s", ErrAlreadyExists, e.Name, e.Version)
-		}
-		return err
-	}
-	return tx.Commit(ctx)
-}
-
-func (db *DB) ListCargoIndexEntries(ctx context.Context, repoName, name string) ([]provider.CargoIndexEntry, error) {
-	rows, err := db.Pool.Query(ctx, `
-		SELECT repo_name, file_path, name, version, line, yanked
-		FROM cargo_index
-		WHERE repo_name = $1 AND lower(name) = $2
-		ORDER BY id
-	`, repoName, strings.ToLower(name))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var result []provider.CargoIndexEntry
-	for rows.Next() {
-		var e provider.CargoIndexEntry
-		if err := rows.Scan(&e.RepoName, &e.FilePath, &e.Name, &e.Version, &e.Line, &e.Yanked); err != nil {
-			return nil, err
-		}
-		result = append(result, e)
-	}
-	return result, rows.Err()
-}
-
-// SetCargoYanked reports false when no such crate version exists.
-func (db *DB) SetCargoYanked(ctx context.Context, repoName, name, version string, yanked bool) (bool, error) {
-	tag, err := db.Pool.Exec(ctx, `
-		UPDATE cargo_index SET yanked = $4
-		WHERE repo_name = $1 AND lower(name) = $2 AND version = $3
-	`, repoName, strings.ToLower(name), version, yanked)
-	if err != nil {
-		return false, err
-	}
-	return tag.RowsAffected() > 0, nil
-}
-
-func (db *DB) DeleteCargoIndexEntry(ctx context.Context, repoName, filePath string) error {
-	_, err := db.Pool.Exec(ctx, `DELETE FROM cargo_index WHERE repo_name = $1 AND file_path = $2`, repoName, filePath)
-	return err
-}

internal/database/database_test.go

@@ -2,10 +2,7 @@ package database
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"os"
-	"sync"
 	"testing"
 	"time"
 
@@ -428,115 +425,3 @@ func TestRPMMetadata(t *testing.T) {
 		t.Fatalf("list rpm rows: %v %v", len(rows), err)
 	}
 }
-
-func TestCargoIndex(t *testing.T) {
-	requireDB(t)
-	for _, v := range []string{"0.1.0", "0.2.0"} {
-		if err := testDB.InsertCargoIndexEntry(ctx(), &provider.CargoIndexEntry{
-			RepoName: "cargo-db", FilePath: "crates/Unkin-Hello/Unkin-Hello-" + v + ".crate",
-			Name: "Unkin-Hello", Version: v, Line: `{"vers":"` + v + `"}`,
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	found, err := testDB.SetCargoYanked(ctx(), "cargo-db", "unkin-hello", "0.1.0", true)
-	if err != nil || !found {
-		t.Fatalf("yank: found=%v err=%v", found, err)
-	}
-	if found, _ := testDB.SetCargoYanked(ctx(), "cargo-db", "unkin-hello", "9.9.9", true); found {
-		t.Error("yank of a missing version reported found")
-	}
-
-	entries, err := testDB.ListCargoIndexEntries(ctx(), "cargo-db", "unkin-hello")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(entries) != 2 || entries[0].Version != "0.1.0" || !entries[0].Yanked || entries[1].Yanked {
-		t.Fatalf("entries = %+v", entries)
-	}
-
-	if err := testDB.DeleteCargoIndexEntry(ctx(), "cargo-db", entries[0].FilePath); err != nil {
-		t.Fatal(err)
-	}
-	if entries, _ = testDB.ListCargoIndexEntries(ctx(), "cargo-db", "UNKIN-HELLO"); len(entries) != 1 {
-		t.Fatalf("after delete: %+v", entries)
-	}
-}
-
-func TestCargoIndexPublishConflicts(t *testing.T) {
-	requireDB(t)
-	entry := func(name, version string) *provider.CargoIndexEntry {
-		return &provider.CargoIndexEntry{
-			RepoName: "cargo-conflict", FilePath: "crates/" + name + "/" + name + "-" + version + ".crate",
-			Name: name, Version: version, Line: "{}",
-		}
-	}
-	if err := testDB.InsertCargoIndexEntry(ctx(), entry("foo-bar", "1.0.0+a")); err != nil {
-		t.Fatal(err)
-	}
-	for _, tc := range []struct {
-		name, version string
-		want          error
-	}{
-		{"foo-bar", "1.0.0+b", ErrAlreadyExists},
-		{"foo-bar", "1.0.0", ErrAlreadyExists},
-		{"Foo-Bar", "2.0.0", ErrCargoNameTaken},
-		{"foo_bar", "2.0.0", ErrCargoNameTaken},
-	} {
-		if err := testDB.InsertCargoIndexEntry(ctx(), entry(tc.name, tc.version)); !errors.Is(err, tc.want) {
-			t.Errorf("%s@%s: err = %v, want %v", tc.name, tc.version, err, tc.want)
-		}
-	}
-	if err := testDB.InsertCargoIndexEntry(ctx(), entry("foo-bar", "1.0.1")); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCargoIndexConcurrentPublish(t *testing.T) {
-	requireDB(t)
-	names := []string{"Race", "race", "RACE", "race", "rAce", "RaCe", "racE", "race"}
-	errs := make(chan error, len(names))
-	var wg sync.WaitGroup
-	for i, name := range names {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			errs <- testDB.InsertCargoIndexEntry(ctx(), &provider.CargoIndexEntry{
-				RepoName: "cargo-race", FilePath: fmt.Sprintf("crates/%s/%d.crate", name, i),
-				Name: name, Version: "1.0.0", Line: "{}",
-			})
-		}()
-	}
-	wg.Wait()
-	close(errs)
-	ok := 0
-	for err := range errs {
-		switch {
-		case err == nil:
-			ok++
-		case !errors.Is(err, ErrAlreadyExists) && !errors.Is(err, ErrCargoNameTaken):
-			t.Errorf("unexpected error: %v", err)
-		}
-	}
-	if ok != 1 {
-		t.Fatalf("%d concurrent publishes succeeded, want 1", ok)
-	}
-	if entries, _ := testDB.ListCargoIndexEntries(ctx(), "cargo-race", "race"); len(entries) > 1 {
-		t.Fatalf("entries = %+v", entries)
-	}
-}
-
-func TestCargoIndexUniqueIndex(t *testing.T) {
-	requireDB(t)
-	insert := func(name, version, path string) error {
-		_, err := testDB.Pool.Exec(ctx(), `INSERT INTO cargo_index (repo_name, file_path, name, version, line) VALUES ('cargo-uniq', $1, $2, $3, '{}')`, path, name, version)
-		return err
-	}
-	if err := insert("a-b", "1.0.0+x", "p1"); err != nil {
-		t.Fatal(err)
-	}
-	if err := insert("A_B", "1.0.0+y", "p2"); err == nil {
-		t.Fatal("unique index allowed a normalised duplicate")
-	}
-}

internal/provider/cargo/local.go

@@ -1,307 +0,0 @@
-package cargo
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/binary"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"net/http"
-	"regexp"
-	"strings"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-// publishDep is a dependency as cargo sends it in the publish metadata.
-type publishDep struct {
-	Name               string   `json:"name"`
-	VersionReq         string   `json:"version_req"`
-	Features           []string `json:"features"`
-	Optional           bool     `json:"optional"`
-	DefaultFeatures    bool     `json:"default_features"`
-	Target             *string  `json:"target"`
-	Kind               string   `json:"kind"`
-	Registry           *string  `json:"registry"`
-	ExplicitNameInToml *string  `json:"explicit_name_in_toml"`
-}
-
-// PublishMeta is the JSON half of a `PUT /api/v1/crates/new` body; fields the
-// index does not carry are ignored.
-type PublishMeta struct {
-	Name        string              `json:"name"`
-	Vers        string              `json:"vers"`
-	Deps        []publishDep        `json:"deps"`
-	Features    map[string][]string `json:"features"`
-	Links       *string             `json:"links"`
-	RustVersion *string             `json:"rust_version"`
-}
-
-type indexDep struct {
-	Name            string   `json:"name"`
-	Req             string   `json:"req"`
-	Features        []string `json:"features"`
-	Optional        bool     `json:"optional"`
-	DefaultFeatures bool     `json:"default_features"`
-	Target          *string  `json:"target"`
-	Kind            string   `json:"kind"`
-	Registry        *string  `json:"registry,omitempty"`
-	Package         *string  `json:"package,omitempty"`
-}
-
-// IndexLine is one line of a sparse index file.
-type IndexLine struct {
-	Name        string              `json:"name"`
-	Vers        string              `json:"vers"`
-	Deps        []indexDep          `json:"deps"`
-	Cksum       string              `json:"cksum"`
-	Features    map[string][]string `json:"features"`
-	Features2   map[string][]string `json:"features2,omitempty"`
-	Yanked      bool                `json:"yanked"`
-	Links       *string             `json:"links,omitempty"`
-	V           int                 `json:"v,omitempty"`
-	RustVersion *string             `json:"rust_version,omitempty"`
-}
-
-// ParsePublish splits a publish body: u32le JSON length, JSON, u32le crate length, crate.
-func ParsePublish(body []byte) (PublishMeta, []byte, error) {
-	var meta PublishMeta
-	jsonBytes, rest, err := lengthPrefixed(body)
-	if err != nil {
-		return meta, nil, fmt.Errorf("metadata: %w", err)
-	}
-	crate, rest, err := lengthPrefixed(rest)
-	if err != nil {
-		return meta, nil, fmt.Errorf("crate: %w", err)
-	}
-	if len(rest) != 0 {
-		return meta, nil, errors.New("trailing bytes after crate")
-	}
-	if err := json.Unmarshal(jsonBytes, &meta); err != nil {
-		return meta, nil, fmt.Errorf("metadata: %w", err)
-	}
-	return meta, crate, nil
-}
-
-func lengthPrefixed(b []byte) ([]byte, []byte, error) {
-	if len(b) < 4 {
-		return nil, nil, errors.New("truncated length")
-	}
-	n := binary.LittleEndian.Uint32(b)
-	b = b[4:]
-	if uint64(n) > uint64(len(b)) {
-		return nil, nil, errors.New("truncated body")
-	}
-	return b[:n], b[n:], nil
-}
-
-// NewIndexLine validates the metadata and translates it into index form.
-func NewIndexLine(meta PublishMeta, crate []byte) (IndexLine, error) {
-	if !validName(meta.Name) {
-		return IndexLine{}, fmt.Errorf("invalid crate name %q", meta.Name)
-	}
-	if !validVersion(meta.Vers) {
-		return IndexLine{}, fmt.Errorf("invalid version %q", meta.Vers)
-	}
-	if len(crate) == 0 {
-		return IndexLine{}, errors.New("empty .crate")
-	}
-	sum := sha256.Sum256(crate)
-	line := IndexLine{
-		Name:        meta.Name,
-		Vers:        meta.Vers,
-		Deps:        make([]indexDep, 0, len(meta.Deps)),
-		Cksum:       hex.EncodeToString(sum[:]),
-		Features:    map[string][]string{},
-		Links:       meta.Links,
-		RustVersion: meta.RustVersion,
-	}
-	for _, d := range meta.Deps {
-		dep := indexDep{
-			Name:            d.Name,
-			Req:             d.VersionReq,
-			Features:        d.Features,
-			Optional:        d.Optional,
-			DefaultFeatures: d.DefaultFeatures,
-			Target:          d.Target,
-			Kind:            d.Kind,
-			Registry:        d.Registry,
-		}
-		if dep.Features == nil {
-			dep.Features = []string{}
-		}
-		if dep.Kind == "" {
-			dep.Kind = "normal"
-		}
-		if d.ExplicitNameInToml != nil && *d.ExplicitNameInToml != "" {
-			pkg := d.Name
-			dep.Name, dep.Package = *d.ExplicitNameInToml, &pkg
-		}
-		line.Deps = append(line.Deps, dep)
-	}
-	// Older cargo cannot parse dep:/?/ feature syntax, so those features live in
-	// features2 behind v:2, as on crates.io.
-	for name, vals := range meta.Features {
-		if vals == nil {
-			vals = []string{}
-		}
-		if usesNewFeatureSyntax(vals) {
-			if line.Features2 == nil {
-				line.Features2 = map[string][]string{}
-			}
-			line.Features2[name] = vals
-			continue
-		}
-		line.Features[name] = vals
-	}
-	if line.Features2 != nil {
-		line.V = 2
-	}
-	return line, nil
-}
-
-func usesNewFeatureSyntax(vals []string) bool {
-	for _, v := range vals {
-		if strings.HasPrefix(v, "dep:") || strings.Contains(v, "?/") {
-			return true
-		}
-	}
-	return false
-}
-
-func validName(name string) bool {
-	if name == "" || len(name) > 64 {
-		return false
-	}
-	for i, c := range name {
-		alpha := (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-		if i == 0 && !alpha {
-			return false
-		}
-		if !alpha && (c < '0' || c > '9') && c != '-' && c != '_' {
-			return false
-		}
-	}
-	return true
-}
-
-// semverRe is the SemVer 2.0.0 grammar from semver.org.
-var semverRe = regexp.MustCompile(`^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$`)
-
-func validVersion(v string) bool {
-	return len(v) <= 128 && semverRe.MatchString(v)
-}
-
-// IndexPath is the sparse-index file path for a crate name.
-func IndexPath(name string) string {
-	n := strings.ToLower(name)
-	switch len(n) {
-	case 0:
-		return ""
-	case 1:
-		return "1/" + n
-	case 2:
-		return "2/" + n
-	case 3:
-		return "3/" + n[:1] + "/" + n
-	}
-	return n[:2] + "/" + n[2:4] + "/" + n
-}
-
-// CratePath is where a published .crate is stored, matching config.json's dl.
-func CratePath(name, version string) string {
-	return crateDir + name + "/" + name + "-" + version + ".crate"
-}
-
-// RenderIndex joins stored lines into an index file with each yanked flag applied.
-func RenderIndex(entries []provider.CargoIndexEntry) ([]byte, error) {
-	var b strings.Builder
-	for _, e := range entries {
-		var line IndexLine
-		if err := json.Unmarshal([]byte(e.Line), &line); err != nil {
-			return nil, fmt.Errorf("%s %s: %w", e.Name, e.Version, err)
-		}
-		line.Yanked = e.Yanked
-		raw, err := json.Marshal(line)
-		if err != nil {
-			return nil, err
-		}
-		b.Write(raw)
-		b.WriteByte('\n')
-	}
-	return []byte(b.String()), nil
-}
-
-// LocalConfig is config.json for a local registry rooted at base.
-func LocalConfig(base string) map[string]string {
-	return map[string]string{
-		"dl":  base + "/" + crateDir + "{crate}/{crate}-{version}.crate",
-		"api": base,
-	}
-}
-
-func (p *Provider) ServeLocalIndex(w http.ResponseWriter, r *http.Request, files provider.FileStore, repoName, path string) bool {
-	path = strings.TrimLeft(path, "/")
-	if path == "config.json" {
-		w.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(w).Encode(LocalConfig(requestBase(r) + "/api/v1/local/" + repoName))
-		return true
-	}
-	name := path[strings.LastIndex(path, "/")+1:]
-	if name == "" || IndexPath(name) != path {
-		return false
-	}
-
-	reader, ok := files.(provider.CargoIndexReader)
-	if !ok {
-		http.Error(w, "cargo index not available", http.StatusInternalServerError)
-		return true
-	}
-	entries, err := reader.ListCargoIndexEntries(r.Context(), repoName, name)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return true
-	}
-	if len(entries) == 0 {
-		http.Error(w, "not found", http.StatusNotFound)
-		return true
-	}
-	body, err := RenderIndex(entries)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return true
-	}
-	w.Header().Set("Content-Type", "text/plain")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write(body)
-	return true
-}
-
-func (p *Provider) GenerateLocalIndex(ctx context.Context, files provider.FileStore, repoName, path string) ([]byte, error) {
-	return nil, fmt.Errorf("cargo local index generation for virtual repos not supported")
-}
-
-func (p *Provider) AfterDelete(ctx context.Context, repoName, storagePath string, db provider.MetadataDeleter) error {
-	deleter, ok := db.(provider.CargoIndexDeleter)
-	if !ok {
-		return nil
-	}
-	if err := deleter.DeleteCargoIndexEntry(ctx, repoName, storagePath); err != nil {
-		slog.Error("cargo index: delete failed", "repo", repoName, "path", storagePath, "error", err)
-		return err
-	}
-	return nil
-}
-
-func requestBase(r *http.Request) string {
-	scheme := "http"
-	if r.TLS != nil {
-		scheme = "https"
-	} else if fwd := r.Header.Get("X-Forwarded-Proto"); fwd != "" {
-		scheme = fwd
-	}
-	return scheme + "://" + r.Host
-}

internal/provider/cargo/local_test.go

@@ -1,232 +0,0 @@
-package cargo
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/binary"
-	"encoding/hex"
-	"encoding/json"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-func publishBody(meta string, crate []byte) []byte {
-	var b []byte
-	b = binary.LittleEndian.AppendUint32(b, uint32(len(meta)))
-	b = append(b, meta...)
-	b = binary.LittleEndian.AppendUint32(b, uint32(len(crate)))
-	return append(b, crate...)
-}
-
-const sampleMeta = `{
-  "name": "unkin-hello", "vers": "0.2.0",
-  "deps": [
-    {"name": "serde", "version_req": "^1", "features": ["derive"], "optional": false,
-     "default_features": true, "target": null, "kind": "normal",
-     "registry": "https://github.com/rust-lang/crates.io-index"},
-    {"name": "rand_core", "version_req": "^0.6", "features": null, "optional": true,
-     "default_features": false, "target": "cfg(unix)", "kind": "dev",
-     "explicit_name_in_toml": "rc"}
-  ],
-  "features": {"default": ["std"], "std": [], "extra": ["dep:rc"], "weak": ["serde?/std"]},
-  "links": null, "rust_version": "1.70", "description": "ignored"
-}`
-
-func TestParsePublishAndIndexLine(t *testing.T) {
-	crate := []byte("fake crate bytes")
-	meta, gotCrate, err := ParsePublish(publishBody(sampleMeta, crate))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(gotCrate) != string(crate) {
-		t.Fatalf("crate = %q", gotCrate)
-	}
-	line, err := NewIndexLine(meta, crate)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sum := sha256.Sum256(crate)
-	if line.Cksum != hex.EncodeToString(sum[:]) {
-		t.Errorf("cksum = %s", line.Cksum)
-	}
-
-	raw, _ := json.Marshal(line)
-	var got map[string]any
-	_ = json.Unmarshal(raw, &got)
-	if _, ok := got["version_req"]; ok {
-		t.Error("publish-only field leaked into index line")
-	}
-	if got["v"] != float64(2) {
-		t.Errorf("v = %v, want 2 with features2 present", got["v"])
-	}
-	if got["rust_version"] != "1.70" {
-		t.Errorf("rust_version = %v", got["rust_version"])
-	}
-	if _, ok := line.Features["extra"]; ok {
-		t.Error("dep: feature must move to features2")
-	}
-	if len(line.Features2) != 2 || len(line.Features) != 2 {
-		t.Errorf("features = %v features2 = %v", line.Features, line.Features2)
-	}
-
-	deps := got["deps"].([]any)
-	serde := deps[0].(map[string]any)
-	if serde["req"] != "^1" || serde["registry"] != "https://github.com/rust-lang/crates.io-index" || serde["target"] != nil {
-		t.Errorf("serde dep = %v", serde)
-	}
-	if _, ok := serde["package"]; ok {
-		t.Error("package set without a rename")
-	}
-	renamed := deps[1].(map[string]any)
-	if renamed["name"] != "rc" || renamed["package"] != "rand_core" || renamed["kind"] != "dev" {
-		t.Errorf("renamed dep = %v", renamed)
-	}
-	if f, ok := renamed["features"].([]any); !ok || len(f) != 0 {
-		t.Errorf("null features must render as [], got %v", renamed["features"])
-	}
-}
-
-func TestIndexLineNoNewFeaturesOmitsV(t *testing.T) {
-	line, err := NewIndexLine(PublishMeta{Name: "a", Vers: "1.0.0", Features: map[string][]string{"x": nil}}, []byte("x"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw, _ := json.Marshal(line)
-	s := string(raw)
-	for _, bad := range []string{`"v":`, `"features2"`, `"links"`} {
-		if strings.Contains(s, bad) {
-			t.Errorf("%s present in %s", bad, s)
-		}
-	}
-	if !strings.Contains(s, `"deps":[]`) || !strings.Contains(s, `"features":{"x":[]}`) {
-		t.Errorf("deps/features must be non-null: %s", s)
-	}
-}
-
-func TestParsePublishRejectsMalformed(t *testing.T) {
-	good := publishBody(`{"name":"a","vers":"1.0.0"}`, []byte("c"))
-	for name, body := range map[string][]byte{
-		"empty":     nil,
-		"short":     good[:len(good)-1],
-		"trailing":  append(append([]byte{}, good...), 'x'),
-		"bad json":  publishBody(`{`, []byte("c")),
-		"no length": good[:6],
-	} {
-		if _, _, err := ParsePublish(body); err == nil {
-			t.Errorf("%s: expected error", name)
-		}
-	}
-}
-
-func TestNewIndexLineValidation(t *testing.T) {
-	for _, m := range []PublishMeta{
-		{Name: "", Vers: "1.0.0"},
-		{Name: "1abc", Vers: "1.0.0"},
-		{Name: "../x", Vers: "1.0.0"},
-		{Name: "ok", Vers: "1.0.0/../../x"},
-		{Name: "ok", Vers: ""},
-		{Name: strings.Repeat("a", 65), Vers: "1.0.0"},
-		{Name: "ok", Vers: "1"},
-		{Name: "ok", Vers: "1.0"},
-		{Name: "ok", Vers: "1..2"},
-		{Name: "ok", Vers: "01.0.0"},
-		{Name: "ok", Vers: "1.0.0-"},
-		{Name: "ok", Vers: "1.0.0-01"},
-		{Name: "ok", Vers: "1.0.0+"},
-		{Name: "ok", Vers: "1.0.0+a..b"},
-		{Name: "ok", Vers: "v1.0.0"},
-	} {
-		if _, err := NewIndexLine(m, []byte("x")); err == nil {
-			t.Errorf("%q@%q accepted", m.Name, m.Vers)
-		}
-	}
-	for _, v := range []string{"0.0.0", "1.0.0-rc.1+build.5", "1.2.3-alpha.0.x-y", "10.20.30+20261017"} {
-		if _, err := NewIndexLine(PublishMeta{Name: "Foo_bar-2", Vers: v}, []byte("x")); err != nil {
-			t.Error(err)
-		}
-	}
-	if _, err := NewIndexLine(PublishMeta{Name: "ok", Vers: "1.0.0"}, nil); err == nil {
-		t.Error("empty .crate accepted")
-	}
-}
-
-func TestIndexPath(t *testing.T) {
-	for name, want := range map[string]string{
-		"a": "1/a", "ab": "2/ab", "abc": "3/a/abc", "Serde": "se/rd/serde", "unkin-hello": "un/ki/unkin-hello",
-	} {
-		if got := IndexPath(name); got != want {
-			t.Errorf("IndexPath(%q) = %q, want %q", name, got, want)
-		}
-	}
-}
-
-type fakeIndex struct {
-	entries []provider.CargoIndexEntry
-	asked   string
-}
-
-func (f *fakeIndex) ListCargoIndexEntries(_ context.Context, _, name string) ([]provider.CargoIndexEntry, error) {
-	f.asked = name
-	return f.entries, nil
-}
-func (f *fakeIndex) ListFilesByPrefix(context.Context, string, string) ([]provider.FileEntry, error) {
-	return nil, nil
-}
-func (f *fakeIndex) ListPackages(context.Context, string) ([]string, error) { return nil, nil }
-
-func TestServeLocalIndex(t *testing.T) {
-	line, _ := NewIndexLine(PublishMeta{Name: "unkin-hello", Vers: "0.1.0"}, []byte("x"))
-	raw, _ := json.Marshal(line)
-	files := &fakeIndex{entries: []provider.CargoIndexEntry{
-		{Name: "unkin-hello", Version: "0.1.0", Line: string(raw), Yanked: true},
-		{Name: "unkin-hello", Version: "0.2.0", Line: strings.Replace(string(raw), "0.1.0", "0.2.0", 1)},
-	}}
-	p := &Provider{}
-
-	rec := httptest.NewRecorder()
-	if !p.ServeLocalIndex(rec, httptest.NewRequest("GET", "http://aa.example/x", nil), files, "crates-local", "un/ki/unkin-hello") {
-		t.Fatal("index path not served")
-	}
-	lines := strings.Split(strings.TrimSpace(rec.Body.String()), "\n")
-	if len(lines) != 2 || !strings.Contains(lines[0], `"yanked":true`) || !strings.Contains(lines[1], `"yanked":false`) {
-		t.Errorf("index body = %q", rec.Body.String())
-	}
-	if files.asked != "unkin-hello" {
-		t.Errorf("looked up %q", files.asked)
-	}
-
-	rec = httptest.NewRecorder()
-	req := httptest.NewRequest("GET", "http://aa.example/config.json", nil)
-	req.Header.Set("X-Forwarded-Proto", "https")
-	p.ServeLocalIndex(rec, req, files, "crates-local", "config.json")
-	var cfg map[string]string
-	_ = json.Unmarshal(rec.Body.Bytes(), &cfg)
-	if cfg["api"] != "https://aa.example/api/v1/local/crates-local" ||
-		cfg["dl"] != "https://aa.example/api/v1/local/crates-local/crates/{crate}/{crate}-{version}.crate" {
-		t.Errorf("config = %v", cfg)
-	}
-
-	for _, path := range []string{"crates/unkin-hello/unkin-hello-0.1.0.crate", "xx/ki/unkin-hello", ""} {
-		if p.ServeLocalIndex(httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil), files, "r", path) {
-			t.Errorf("%q should fall through", path)
-		}
-	}
-
-	files.entries = nil
-	rec = httptest.NewRecorder()
-	p.ServeLocalIndex(rec, httptest.NewRequest("GET", "/", nil), files, "r", "3/a/abc")
-	if rec.Code != 404 {
-		t.Errorf("unknown crate code = %d", rec.Code)
-	}
-}
-
-func TestCratePathMatchesDL(t *testing.T) {
-	dl := LocalConfig("http://h/api/v1/local/r")["dl"]
-	want := strings.NewReplacer("{crate}", "unkin-hello", "{version}", "0.1.0").Replace(dl)
-	if got := "http://h/api/v1/local/r/" + CratePath("unkin-hello", "0.1.0"); got != want {
-		t.Errorf("CratePath = %q, dl expands to %q", got, want)
-	}
-}

internal/provider/cargo_index.go

@@ -1,24 +0,0 @@
-package provider
-
-import "context"
-
-// CargoIndexEntry is one published crate version in a local cargo registry.
-// Line is the sparse-index JSON line; Yanked is applied when it is served.
-type CargoIndexEntry struct {
-	RepoName string
-	FilePath string
-	Name     string
-	Version  string
-	Line     string
-	Yanked   bool
-}
-
-// CargoIndexReader lists every version of one crate (matched case-insensitively).
-// *database.DB satisfies it and CargoIndexDeleter.
-type CargoIndexReader interface {
-	ListCargoIndexEntries(ctx context.Context, repoName, name string) ([]CargoIndexEntry, error)
-}
-
-type CargoIndexDeleter interface {
-	DeleteCargoIndexEntry(ctx context.Context, repoName, filePath string) error
-}

internal/provider/helm/helm.go

@@ -39,6 +39,8 @@ func (p *Provider) UpstreamURL(remote models.Remote, path string) string {
 	return strings.TrimRight(remote.BaseURL, "/") + "/" + strings.TrimLeft(path, "/")
 }
 
+func (p *Provider) RewritesResponse() {}
+
 func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseURL string) ([]byte, error) {
 	if proxyBaseURL == "" {
 		return nil, nil

internal/provider/npm/npm.go

@@ -37,6 +37,8 @@ func (p *Provider) UpstreamURL(remote models.Remote, path string) string {
 	return strings.TrimRight(remote.BaseURL, "/") + "/" + strings.TrimLeft(path, "/")
 }
 
+func (p *Provider) RewritesResponse() {}
+
 func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseURL string) ([]byte, error) {
 	if proxyBaseURL == "" || !json.Valid(body) {
 		return nil, nil

internal/provider/nuget/nuget.go

@@ -1,5 +1,6 @@
 // Package nuget proxies a NuGet v3 feed: the service index, registration pages
-// and flat container indexes are mutable, .nupkg/.nuspec downloads immutable.
+// and flat container indexes are mutable; package, symbol, nuspec, readme and
+// icon blobs are immutable.
 package nuget
 
 import (
@@ -7,6 +8,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/url"
+	pathpkg "path"
 	"strings"
 
 	"git.unkin.net/unkin/artifactapi/internal/auth"
@@ -34,10 +36,12 @@ func (p *Provider) Classify(path string) provider.Mutability {
 
 func (p *Provider) ContentType(path string) string {
 	switch {
-	case strings.HasSuffix(path, ".nupkg"):
+	case strings.HasSuffix(path, ".nupkg"), strings.HasSuffix(path, ".snupkg"), pathpkg.Base(path) == "icon":
 		return "application/octet-stream"
 	case strings.HasSuffix(path, ".nuspec"):
 		return "application/xml"
+	case pathpkg.Base(path) == "readme":
+		return "text/markdown"
 	}
 	return "application/json"
 }
@@ -64,8 +68,8 @@ func (p *Provider) RewriteServed(body []byte, remote models.Remote, proxyBaseURL
 	if from == "" || !json.Valid(body) {
 		return body
 	}
-	to := strings.TrimRight(proxyBaseURL, "/") + "/api/v1/remote/" + remote.Name
-	return []byte(strings.ReplaceAll(string(body), from, to))
+	to, _ := json.Marshal(strings.TrimRight(proxyBaseURL, "/") + "/api/v1/remote/" + remote.Name)
+	return []byte(strings.ReplaceAll(string(body), from, string(to[1:len(to)-1])))
 }
 
 func (p *Provider) AuthHeaders(_ context.Context, remote models.Remote) (http.Header, error) {
@@ -80,6 +84,14 @@ func origin(baseURL string) string {
 	return u.Scheme + "://" + u.Host
 }
 
+// isPackage matches flat container blobs: {id}.{ver}.(s)nupkg, {id}.nuspec and
+// the {id}/{ver}/readme and {id}/{ver}/icon files.
 func isPackage(path string) bool {
-	return strings.HasSuffix(path, ".nupkg") || strings.HasSuffix(path, ".nuspec")
+	for _, ext := range []string{".nupkg", ".snupkg", ".nuspec"} {
+		if strings.HasSuffix(path, ext) {
+			return true
+		}
+	}
+	base := pathpkg.Base(path)
+	return (base == "readme" || base == "icon") && strings.Count(strings.Trim(path, "/"), "/") >= 2
 }

internal/provider/nuget/nuget_test.go

@@ -19,7 +19,11 @@ func TestClassify(t *testing.T) {
 	}{
 		{"v3-flatcontainer/newtonsoft.json/13.0.3/newtonsoft.json.13.0.3.nupkg", provider.Immutable},
 		{"v3-flatcontainer/newtonsoft.json/13.0.3/newtonsoft.json.nuspec", provider.Immutable},
+		{"v3-flatcontainer/newtonsoft.json/13.0.3/newtonsoft.json.13.0.3.snupkg", provider.Immutable},
+		{"v3-flatcontainer/newtonsoft.json/13.0.3/readme", provider.Immutable},
+		{"v3-flatcontainer/newtonsoft.json/13.0.3/icon", provider.Immutable},
 		{"v3-flatcontainer/newtonsoft.json/index.json", provider.Mutable},
+		{"readme", provider.Mutable},
 		{"v3/registration5-gz-semver2/newtonsoft.json/index.json", provider.Mutable},
 		{"index.json", provider.Mutable},
 	}
@@ -30,6 +34,28 @@ func TestClassify(t *testing.T) {
 	}
 }
 
+func TestContentType(t *testing.T) {
+	p := &Provider{}
+	for path, want := range map[string]string{
+		"v3-flatcontainer/a/1.0.0/a.1.0.0.snupkg": "application/octet-stream",
+		"v3-flatcontainer/a/1.0.0/icon":           "application/octet-stream",
+		"v3-flatcontainer/a/1.0.0/readme":         "text/markdown",
+		"v3-flatcontainer/a/index.json":           "application/json",
+	} {
+		if got := p.ContentType(path); got != want {
+			t.Errorf("ContentType(%q) = %q, want %q", path, got, want)
+		}
+	}
+}
+
+func TestRewriteServedEscapesJSON(t *testing.T) {
+	body := `{"@id":"https://api.nuget.org/v3-flatcontainer/"}`
+	got := (&Provider{}).RewriteServed([]byte(body), nugetOrg, `http://evil"<x>`)
+	if want := `{"@id":"http://evil\"\u003cx\u003e/api/v1/remote/nuget-org/v3-flatcontainer/"}`; string(got) != want {
+		t.Errorf("RewriteServed = %s, want %s", got, want)
+	}
+}
+
 func TestUpstreamURL(t *testing.T) {
 	p := &Provider{}
 	tests := []struct {

internal/provider/provider.go

@@ -82,6 +82,12 @@ type ServeRewriter interface {
 	RewriteServed(body []byte, remote models.Remote, proxyBaseURL string) []byte
 }
 
+// ResponseRewriter marks providers whose RewriteResponse changes mutable
+// bodies, so the served length is only known after a fetch.
+type ResponseRewriter interface {
+	RewritesResponse()
+}
+
 // RemoteMetadataStore is the persistence surface a RemoteServer needs to cache
 // and read the metadata it derives per upstream asset. *database.DB satisfies it.
 type RemoteMetadataStore interface {

internal/provider/puppet/puppet.go

@@ -39,6 +39,8 @@ func (p *Provider) UpstreamURL(remote models.Remote, path string) string {
 	return strings.TrimRight(remote.BaseURL, "/") + "/" + strings.TrimLeft(path, "/")
 }
 
+func (p *Provider) RewritesResponse() {}
+
 func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseURL string) ([]byte, error) {
 	if proxyBaseURL == "" {
 		return nil, nil

internal/provider/pypi/pypi.go

@@ -52,6 +52,8 @@ func (p *Provider) UpstreamURL(remote models.Remote, path string) string {
 	return strings.TrimRight(remote.BaseURL, "/") + "/" + strings.TrimLeft(path, "/")
 }
 
+func (p *Provider) RewritesResponse() {}
+
 func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseURL string) ([]byte, error) {
 	if proxyBaseURL == "" {
 		return nil, nil

internal/provider/terraform/terraform.go

@@ -73,6 +73,8 @@ func (p *Provider) UpstreamURL(remote models.Remote, path string) string {
 	return strings.TrimRight(remote.BaseURL, "/") + "/v1/providers/" + strings.TrimLeft(path, "/")
 }
 
+func (p *Provider) RewritesResponse() {}
+
 func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseURL string) ([]byte, error) {
 	if remote.ReleasesRemote == "" {
 		return nil, nil

internal/proxy/engine.go

@@ -353,7 +353,7 @@ func (e *Engine) headUpstreamOnce(ctx context.Context, remote models.Remote, pat
 				req.Header.Set(k, v)
 			}
 		}
-		return http.DefaultClient.Do(req)
+		return clientForRemote(remote).Do(req)
 	}
 
 	resp, err := doHead(nil)

internal/proxy/engine_test.go

@@ -216,6 +216,20 @@ func TestHead(t *testing.T) {
 	}
 }
 
+func TestHeadUpstreamUsesRemoteTimeout(t *testing.T) {
+	slow := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		time.Sleep(3 * time.Second)
+	}))
+	defer slow.Close()
+	r := models.Remote{Name: "slow-head", PackageType: models.PackageGeneric, BaseURL: slow.URL, UpstreamResponseHeaderTimeout: 1}
+
+	start := time.Now()
+	_, err := (&Engine{}).headUpstreamOnce(context.Background(), r, "blob.bin", prov(t, models.PackageGeneric))
+	if err == nil || time.Since(start) > 2*time.Second {
+		t.Fatalf("HEAD ignored the remote's response header timeout: err=%v after %s", err, time.Since(start))
+	}
+}
+
 func TestStaleOnError(t *testing.T) {
 	requireStack(t)
 	ctx := context.Background()

migrations/0005_cargo_index.sql

@@ -1,19 +0,0 @@
--- Local cargo registries: one sparse-index line per published crate version.
--- line holds the index JSON minus yanked, which flips on yank/unyank.
-CREATE TABLE IF NOT EXISTS cargo_index (
-	id           BIGSERIAL PRIMARY KEY,
-	repo_name    TEXT NOT NULL,
-	file_path    TEXT NOT NULL,
-	name         TEXT NOT NULL,
-	version      TEXT NOT NULL,
-	line         TEXT NOT NULL,
-	yanked       BOOLEAN NOT NULL DEFAULT FALSE,
-	created_at   TIMESTAMPTZ DEFAULT NOW(),
-	UNIQUE(repo_name, file_path)
-);
-
-CREATE INDEX IF NOT EXISTS idx_cargo_index_repo_name ON cargo_index(repo_name, lower(name));
-
--- Cargo treats names equal up to case and -/_, and versions equal up to build metadata.
-CREATE UNIQUE INDEX IF NOT EXISTS idx_cargo_index_unique_version
-	ON cargo_index(repo_name, replace(lower(name), '-', '_'), split_part(version, '+', 1));

ui/src/components/UsageInstructions.tsx

@@ -229,25 +229,6 @@ go mod download`,
       ];
 
     case 'cargo':
-      if (isLocal) {
-        return [
-          {
-            title: 'Add the private registry (real sparse registry)',
-            language: 'toml',
-            code: `# $CARGO_HOME/config.toml
-[registries.${name}]
-index = "sparse+${url}/api/v1/local/${name}/"`,
-            note: 'cargo requires a token for publish/yank: set CARGO_REGISTRIES_' + name.toUpperCase().replace(/-/g, '_') + '_TOKEN to any value.',
-          },
-          {
-            title: 'Publish, depend on and yank crates',
-            language: 'bash',
-            code: `cargo publish --registry ${name}
-cargo add <crate> --registry ${name}
-cargo yank --version <version> --registry ${name}`,
-          },
-        ];
-      }
       return [
         {
           title: 'Point crates.io at this sparse registry',