mirror of
https://github.com/mudler/LocalAI.git
synced 2026-06-14 11:49:33 -04:00
12d1f3a697
LocalAI's outbound HTTP clients used Go's default redirect policy, which
follows up to 10 redirects. On a cross-host redirect Go forwards custom
request headers — including credential headers such as Anthropic's
x-api-key — to the redirect target (Go strips Authorization, Cookie and
WWW-Authenticate cross-host, but NOT arbitrary custom headers). An
attacker able to elicit a redirect from an upstream (a hijacked or
spoofed upstream, DNS trickery, or a malicious upstream_url) then
harvests the operator's provider API key.
This was first reported against the cloud-proxy / MITM PII path
(GHSA-3mj3-57v2-4636); the same class affects every other outbound
client. Rather than patch each call site, add pkg/httpclient as the one
sanctioned constructor for outbound HTTP and route everything through it.
pkg/httpclient:
- New(...) refuses redirects, TLS 1.2 floor, no body
deadline (streaming/SSE safe)
- NewWithTimeout(d) simple request/response calls
- WithFollowRedirects opt-in following that still strips credential
headers on any cross-host hop; different
scheme/host/port == different origin, guarding
the curl CVE-2022-27774 port-confusion class
- WithTransport(rt) keep a custom transport (IP-pin, HTTP/2, a
credential-injecting RoundTripper)
- HardenedTransport() base transport with the TLS floor + bounded setup
- Harden(c) apply the policy to a library-supplied *http.Client
- NoRedirect the CheckRedirect policy; wraps ErrRedirectBlocked
Lint: a forbidigo rule flags http.DefaultClient and http.Get/Post/
PostForm/Head, pointing at pkg/httpclient (.golangci.yml,
.agents/coding-style.md). forbidigo cannot match the &http.Client{}
composite literal without also flagging legitimate *http.Client type
references, so that form is enforced by review.
Migrates every non-test outbound call site across core/, pkg/, cmd/, and
the Go backend (backend/go/cloud-proxy). Credential-bearing and
internal-RPC clients refuse redirects; download / CDN / registry clients
use WithFollowRedirects so they keep working while stripping secrets
cross-host. The only credential-bearing client that follows redirects is
the gated-download path (pkg/downloader/uri.go), which strips the token
on the cross-host hop to the CDN. Hardening this closes, in passing:
- MCP remote-server bearer token leaking via a redirect (the
RoundTripper re-injected Authorization on every hop)
- agent multimedia/webhook clients leaking user-supplied auth headers
- cors_proxy following redirects, bypassing its SSRF IP-pin
- downloader's authorized read path leaking the token cross-host
Fixes: GHSA-3mj3-57v2-4636 (cloud-proxy leaks operator provider API key
(x-api-key) to attacker host on cross-host redirect)
Reported-by: tonghuaroot
Assisted-by: Claude:claude-opus-4-8 [Claude Code]
Signed-off-by: Richard Palethorpe <io@richiejp.com>
55 lines
1.7 KiB
Go
55 lines
1.7 KiB
Go
package downloader
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"github.com/mudler/LocalAI/pkg/httpclient"
|
|
)
|
|
|
|
type HuggingFaceScanResult struct {
|
|
RepositoryId string `json:"repositoryId"`
|
|
Revision string `json:"revision"`
|
|
HasUnsafeFiles bool `json:"hasUnsafeFile"`
|
|
ClamAVInfectedFiles []string `json:"clamAVInfectedFiles"`
|
|
DangerousPickles []string `json:"dangerousPickles"`
|
|
ScansDone bool `json:"scansDone"`
|
|
}
|
|
|
|
var ErrNonHuggingFaceFile = errors.New("not a huggingface repo")
|
|
var ErrUnsafeFilesFound = errors.New("unsafe files found")
|
|
|
|
func HuggingFaceScan(uri URI) (*HuggingFaceScanResult, error) {
|
|
cleanParts := strings.Split(uri.ResolveURL(), "/")
|
|
// cleanParts[2] is the hostname from the URL (e.g. "huggingface.co" or "hf-mirror.com").
|
|
// Extract the hostname from HF_ENDPOINT for comparison, since HF_ENDPOINT includes the scheme.
|
|
hfHost := strings.TrimPrefix(strings.TrimPrefix(HF_ENDPOINT, "https://"), "http://")
|
|
if len(cleanParts) <= 4 || (cleanParts[2] != "huggingface.co" && cleanParts[2] != hfHost) {
|
|
return nil, ErrNonHuggingFaceFile
|
|
}
|
|
results, err := httpclient.New(httpclient.WithFollowRedirects()).Get(fmt.Sprintf("%s/api/models/%s/%s/scan", HF_ENDPOINT, cleanParts[3], cleanParts[4]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer results.Body.Close()
|
|
if results.StatusCode != 200 {
|
|
return nil, fmt.Errorf("unexpected status code during HuggingFaceScan: %d", results.StatusCode)
|
|
}
|
|
scanResult := &HuggingFaceScanResult{}
|
|
bodyBytes, err := io.ReadAll(results.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = json.Unmarshal(bodyBytes, scanResult)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if scanResult.HasUnsafeFiles {
|
|
return scanResult, ErrUnsafeFilesFound
|
|
}
|
|
return scanResult, nil
|
|
}
|