Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

plugin: Bun reads the system's trust store itself (NODE_USE_SYSTEM_CA)

yetone955cb4381241
diff --git a/internal/plugin/systemca.go b/internal/plugin/systemca.go
index d9eeb6e53..e5b7fe120 100644
--- a/internal/plugin/systemca.go
+++ b/internal/plugin/systemca.go
@@ -16,24 +16,50 @@ import (
// caEnv has Bun trust what this machine trusts. Bun checks TLS against
// the roots it ships, not the system's, so behind a box that re-signs
-// HTTPS (a company proxy, a VPN, Surge's or Proxyman's MITM) whose root
-// the user installed, magpie gets through and Bun doesn't: `bun add`
-// fails with "UNABLE_TO_VERIFY_LEAF_SIGNATURE downloading package
-// manifest", and a plugin's requests fail the same way. NODE_EXTRA_CA_CERTS
-// adds the system's roots to Bun's, for installs and for the host alike.
-// One the environment sets already is the user's and is left as it is.
-// dir is where Bun runs.
+// HTTPS (a company proxy, a VPN, Surge's or Proxyman's MITM, an
+// antivirus's HTTPS scan) whose root the user installed, magpie gets
+// through and Bun doesn't: `bun add` fails with
+// "UNABLE_TO_VERIFY_LEAF_SIGNATURE downloading package manifest" or
+// UNABLE_TO_GET_ISSUER_CERT_LOCALLY, and a plugin's requests with "self
+// signed certificate in certificate chain" (明霞 on Discord, Windows).
+//
+// NODE_USE_SYSTEM_CA=1 has Bun read the system's store itself, for the
+// runtime's fetch and for bun add's downloads alike (both take
+// us_get_default_ca_store, Bun 1.4.2): on Windows the ROOT, CA and
+// TrustedPeople stores of the machine, the user, group policy and the
+// enterprise, each certificate valid for server auth (an intermediate a
+// proxy doesn't send, and a root a policy installed, among them); on
+// macOS the keychains' trust settings; elsewhere $SSL_CERT_FILE and
+// $SSL_CERT_DIR, else the distribution's bundle and folder. One the
+// environment sets already, 0 too, is the user's and is left as it is.
+//
+// NODE_EXTRA_CA_CERTS adds a file of the system's roots as magpie reads
+// them, as before: an older Bun the user points MAGPIE_BUN at has no
+// NODE_USE_SYSTEM_CA. One the environment sets already is the user's and
+// is left as it is; Bun takes it beside the system's store. dir is where
+// Bun runs.
func caEnv(env []string, dir string) []string {
+ var out []string
+ if !envSet(env, "NODE_USE_SYSTEM_CA") {
+ out = append(out, "NODE_USE_SYSTEM_CA=1")
+ }
+ if !envSet(env, "NODE_EXTRA_CA_CERTS") {
+ if p := systemCAFile(); p != "" {
+ out = append(out, "NODE_EXTRA_CA_CERTS="+bunReadable(p, dir, runtime.GOOS))
+ }
+ }
+ return out
+}
+
+// envSet is whether env gives name a value that isn't blank.
+func envSet(env []string, name string) bool {
for _, kv := range env {
k, v, _ := strings.Cut(kv, "=")
- if strings.ToUpper(k) == "NODE_EXTRA_CA_CERTS" && strings.TrimSpace(v) != "" {
- return nil
+ if strings.EqualFold(k, name) && strings.TrimSpace(v) != "" {
+ return true
}
}
- if p := systemCAFile(); p != "" {
- return []string{"NODE_EXTRA_CA_CERTS=" + bunReadable(p, dir, runtime.GOOS)}
- }
- return nil
+ return false
}
// bunReadable is p as a Bun on goos can open it. Bun on Windows reads
diff --git a/internal/plugin/systemca_bun_test.go b/internal/plugin/systemca_bun_test.go
new file mode 100644
index 000000000..971ca3a6f
--- /dev/null
+++ b/internal/plugin/systemca_bun_test.go
@@ -0,0 +1,190 @@
+package plugin
+
+import (
+ "archive/tar"
+ "bytes"
+ "compress/gzip"
+ "context"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/rand"
+ "crypto/sha512"
+ "crypto/tls"
+ "crypto/x509"
+ "crypto/x509/pkix"
+ "encoding/base64"
+ "encoding/json"
+ "encoding/pem"
+ "fmt"
+ "math/big"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/yetone/magpie/internal/testenv"
+)
+
+// reSigningCA is a root as an HTTPS-scanning antivirus or a company proxy
+// installs it, and a server whose certificate it signed: what Bun meets
+// behind such a box. The server sends its chain with the root in it, as
+// those boxes do, and serves an npm registry with one package.
+func reSigningCA(t *testing.T) (caPEM []byte, url string) {
+ t.Helper()
+ caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+ caTpl := &x509.Certificate{
+ SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "magpie test HTTPS scan root"},
+ NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour),
+ IsCA: true, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
+ }
+ caDER, err := x509.CreateCertificate(rand.Reader, caTpl, caTpl, &caKey.PublicKey, caKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ ca, _ := x509.ParseCertificate(caDER)
+ leafKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+ leafTpl := &x509.Certificate{
+ SerialNumber: big.NewInt(2), Subject: pkix.Name{CommonName: "127.0.0.1"},
+ IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, DNSNames: []string{"localhost"},
+ NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour),
+ KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+ }
+ leafDER, err := x509.CreateCertificate(rand.Reader, leafTpl, ca, &leafKey.PublicKey, caKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ const pkg = "magpie-ca-probe"
+ var tgz bytes.Buffer
+ gz := gzip.NewWriter(&tgz)
+ tw := tar.NewWriter(gz)
+ body := []byte(`{"name":"` + pkg + `","version":"1.0.0"}`)
+ _ = tw.WriteHeader(&tar.Header{Name: "package/package.json", Mode: 0o644, Size: int64(len(body)), ModTime: time.Now()})
+ _, _ = tw.Write(body)
+ _ = tw.Close()
+ _ = gz.Close()
+ sum := sha512.Sum512(tgz.Bytes())
+
+ var srv *httptest.Server
+ srv = httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch r.URL.Path {
+ case "/" + pkg:
+ v := map[string]any{"name": pkg, "version": "1.0.0", "dist": map[string]any{
+ "tarball": srv.URL + "/" + pkg + "-1.0.0.tgz",
+ "integrity": "sha512-" + base64.StdEncoding.EncodeToString(sum[:]),
+ }}
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]any{"name": pkg, "dist-tags": map[string]string{"latest": "1.0.0"},
+ "versions": map[string]any{"1.0.0": v}})
+ case "/" + pkg + "-1.0.0.tgz":
+ _, _ = w.Write(tgz.Bytes())
+ default:
+ fmt.Fprint(w, "through")
+ }
+ }))
+ srv.TLS = &tls.Config{Certificates: []tls.Certificate{{Certificate: [][]byte{leafDER, caDER}, PrivateKey: leafKey}}}
+ srv.StartTLS()
+ t.Cleanup(srv.Close)
+ return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: caDER}), srv.URL
+}
+
+// Behind a box that re-signs HTTPS with a root the system trusts, Bun's
+// fetch (the plugin host's) and bun add (a plugin's install or update)
+// get through (明霞 on Discord: every plugin answered "self signed
+// certificate in certificate chain", and an update failed with
+// UNABLE_TO_GET_ISSUER_CERT_LOCALLY). They do with the root in the
+// system's store, and with it in a NODE_EXTRA_CA_CERTS of the user's
+// own; with it in neither, they still refuse the server.
+//
+// The system's store is put in place without touching the machine's:
+// on Linux through SSL_CERT_DIR, which Bun reads as the system's store
+// and which magpie's own copy of the roots (the distribution's bundle)
+// never took in. macOS and Windows have no such variable, so there only
+// the user's file and the refusal are tried.
+func TestBunTrustsTheSystemsStore(t *testing.T) {
+ bun := testenv.Bun(t)
+ sandbox(t)
+ for _, k := range []string{"HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy",
+ "NODE_EXTRA_CA_CERTS", "NODE_USE_SYSTEM_CA", "NODE_TLS_REJECT_UNAUTHORIZED", "SSL_CERT_FILE", "SSL_CERT_DIR"} {
+ t.Setenv(k, "")
+ }
+ t.Setenv("NO_PROXY", "127.0.0.1,localhost")
+ caPEM, url := reSigningCA(t)
+ other, _ := reSigningCA(t) // a root the system trusts that isn't this server's
+ old := systemCAFile
+ t.Cleanup(func() { systemCAFile = old })
+ // read again for each case, not once a run
+ systemCAFile = func() string { return systemCABundle() }
+
+ write := func(name string, b []byte) string {
+ p := filepath.Join(t.TempDir(), name)
+ if err := os.WriteFile(p, b, 0o644); err != nil {
+ t.Fatal(err)
+ }
+ return p
+ }
+ run := func(args ...string) (string, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+ defer cancel()
+ dir := t.TempDir()
+ if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"name":"p","private":true}`), 0o644); err != nil {
+ t.Fatal(err)
+ }
+ cmd := bunCommand(ctx, bun, dir, args...)
+ // a cache of its own each time, so no case installs from another's
+ cmd.Env = append(cmd.Env, "BUN_INSTALL_CACHE_DIR="+t.TempDir(), "BUN_CONFIG_REGISTRY="+url+"/")
+ out, err := cmd.CombinedOutput()
+ return string(out), err
+ }
+ fetch := `const r = await fetch(` + strconv.Quote(url) + `); console.log(await r.text())`
+ try := func(t *testing.T, want bool) {
+ t.Helper()
+ out, err := run("-e", fetch)
+ if got := err == nil && strings.Contains(out, "through"); got != want {
+ t.Errorf("Bun's fetch got through: %v, want %v (%v)\n%s", got, want, err, out)
+ }
+ out, err = run("add", "--ignore-scripts", "magpie-ca-probe")
+ if got := err == nil; got != want {
+ t.Errorf("bun add got through: %v, want %v (%v)\n%s", got, want, err, out)
+ }
+ }
+
+ t.Run("in neither", func(t *testing.T) {
+ if runtime.GOOS == "linux" {
+ // the machine's store, with no root of this server's
+ t.Setenv("SSL_CERT_FILE", write("bundle.pem", other))
+ }
+ try(t, false)
+ })
+ t.Run("in the system's store", func(t *testing.T) {
+ if runtime.GOOS != "linux" {
+ t.Skip("the system's store here can't be given a root without changing the machine's")
+ }
+ t.Setenv("SSL_CERT_FILE", write("bundle.pem", other))
+ dir := t.TempDir()
+ if err := os.WriteFile(filepath.Join(dir, "https-scan-root.pem"), caPEM, 0o644); err != nil {
+ t.Fatal(err)
+ }
+ t.Setenv("SSL_CERT_DIR", dir)
+ try(t, true)
+ })
+ t.Run("in the user's NODE_EXTRA_CA_CERTS", func(t *testing.T) {
+ if runtime.GOOS == "linux" {
+ t.Setenv("SSL_CERT_FILE", write("bundle.pem", other))
+ }
+ t.Setenv("NODE_EXTRA_CA_CERTS", write("mine.pem", caPEM))
+ try(t, true)
+ })
+}
diff --git a/internal/plugin/systemca_test.go b/internal/plugin/systemca_test.go
index c8e6d7060..3ed9ce9c8 100644
--- a/internal/plugin/systemca_test.go
+++ b/internal/plugin/systemca_test.go
@@ -33,11 +33,55 @@ func TestBunIsGivenTheSystemsRoots(t *testing.T) {
}
systemCAFile = func() string { return "" }
- if got := caEnv(nil, ""); got != nil {
- t.Fatalf("with nothing to add: %v", got)
+ if got := caEnv(nil, ""); !slices.Equal(got, []string{"NODE_USE_SYSTEM_CA=1"}) {
+ t.Fatalf("with no file to add: %v, want Bun to read the system's store itself", got)
}
}
+// Bun reads the system's store itself (NODE_USE_SYSTEM_CA): magpie's copy
+// of the ROOT store missed what Bun's own reading has (the CA store's
+// intermediates a proxy doesn't send, the enterprise's and group
+// policy's roots), and a plugin answered "self signed certificate in
+// certificate chain" while bun add failed with
+// UNABLE_TO_GET_ISSUER_CERT_LOCALLY (明霞 on Discord). A value the user
+// gives it, 0 too, is theirs.
+func TestBunReadsTheSystemsStore(t *testing.T) {
+ old := systemCAFile
+ t.Cleanup(func() { systemCAFile = old })
+ systemCAFile = func() string { return "/cache/bun/system-ca-abc.pem" }
+ t.Setenv("NODE_EXTRA_CA_CERTS", "")
+ t.Setenv("NODE_USE_SYSTEM_CA", "")
+
+ cmd := bunCommand(context.Background(), "bun", t.TempDir(), "run", "host.js")
+ if got := envVars(cmd.Env, "NODE_USE_SYSTEM_CA"); !slices.Equal(got, []string{"NODE_USE_SYSTEM_CA=1"}) {
+ t.Fatalf("Bun isn't told to read the system's store: %v", got)
+ }
+
+ // the user's own file of roots is taken beside the system's store
+ t.Setenv("NODE_EXTRA_CA_CERTS", "/mine.pem")
+ cmd = bunCommand(context.Background(), "bun", t.TempDir(), "add", "x")
+ if got := envVars(cmd.Env, "NODE_USE_SYSTEM_CA"); !slices.Equal(got, []string{"NODE_USE_SYSTEM_CA=1"}) {
+ t.Fatalf("with the user's NODE_EXTRA_CA_CERTS: %v", got)
+ }
+
+ t.Setenv("NODE_USE_SYSTEM_CA", "0")
+ cmd = bunCommand(context.Background(), "bun", t.TempDir(), "add", "x")
+ if got := envVars(cmd.Env, "NODE_USE_SYSTEM_CA"); !slices.Equal(got, []string{"NODE_USE_SYSTEM_CA=0"}) {
+ t.Fatalf("the user's own NODE_USE_SYSTEM_CA = %v, want it alone", got)
+ }
+}
+
+func envVars(env []string, name string) []string {
+ var out []string
+ for _, kv := range env {
+ // a blank one (t.Setenv's "") is no value; exec takes the last
+ if strings.HasPrefix(strings.ToUpper(kv), name+"=") && kv != name+"=" {
+ out = append(out, kv)
+ }
+ }
+ return out
+}
+
func caVars(env []string) []string {
var out []string
for _, kv := range env {