Files
sam db346b159d fix(webui): mark cookies Secure behind a TLS proxy; run gosec in the gate (#1919)
Cookies took Secure from r.TLS, which is nil behind a proxy that terminates
TLS, so sign-in cookies went out without it. Every dashboard cookie now goes
through one builder that reads the scheme the way the origin check does.

The worktree reset and the agent worker's chown walk use os.Root, so a
symlink swapped in mid-walk can't point them outside the worktree.

gosec runs in golangci-lint, tests included. G104, G115, G204 and G304 are
excluded in config; each remaining finding is fixed or suppressed at the site
with its reason.
2026-11-13 03:16:15 +11:00

316 lines
11 KiB
Go

package secretengine
import (
"archive/tar"
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"io"
"log/slog"
"net"
"net/http"
"net/http/httptest"
"net/url"
"os"
"strings"
"testing"
"time"
goplugin "github.com/hashicorp/go-plugin"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
secretenginev1 "github.com/samcharles93/archie-core/internal/contracts/secretengine/v1"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
"github.com/samcharles93/archie-core/internal/secret"
)
// echoEngine is the extension the test binary becomes when the host launches
// it: "ENV:NAME" resolves to that variable as the plugin process sees it, any
// other key to a value derived from the Configure settings.
type echoEngine struct {
secretenginev1.UnimplementedSecretEngineServiceServer
settings map[string]string
}
func (e *echoEngine) Configure(_ context.Context, r *secretenginev1.ConfigureRequest) (*secretenginev1.ConfigureResponse, error) {
e.settings = r.GetSettings()
return &secretenginev1.ConfigureResponse{}, nil
}
func (e *echoEngine) Resolve(ctx context.Context, r *secretenginev1.ResolveRequest) (*secretenginev1.ResolveResponse, error) {
if name, ok := strings.CutPrefix(r.GetKey(), "ENV:"); ok {
return &secretenginev1.ResolveResponse{Value: os.Getenv(name)}, nil
}
if url, ok := strings.CutPrefix(r.GetKey(), "GET:"); ok {
return &secretenginev1.ResolveResponse{Value: fetch(url)}, nil
}
if addr, ok := strings.CutPrefix(r.GetKey(), "DIAL:"); ok {
return &secretenginev1.ResolveResponse{Value: dial(ctx, addr)}, nil
}
if v, ok := e.settings[r.GetKey()]; ok {
return &secretenginev1.ResolveResponse{Value: v}, nil
}
return nil, status.Error(codes.NotFound, "no such key")
}
// dial reports whether a raw TCP connection to addr succeeds.
func dial(ctx context.Context, addr string) string {
conn, err := (&net.Dialer{Timeout: 2 * time.Second}).DialContext(ctx, "tcp", addr)
if err != nil {
return "dial failed"
}
_ = conn.Close()
return "connected"
}
// fetch GETs target through the proxy HTTP_PROXY names, reporting the body or
// the failing status. The proxy is set explicitly because the environment
// lookup never proxies loopback, which is where the test servers listen.
func fetch(target string) string {
proxy, err := url.Parse(os.Getenv("HTTP_PROXY"))
if err != nil || proxy.Host == "" {
return "no proxy"
}
client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}, Timeout: 5 * time.Second}
resp, err := client.Get(target) //nolint:noctx // test plugin
if err != nil {
return "error: " + err.Error()
}
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return resp.Status
}
body, _ := io.ReadAll(resp.Body)
return string(body)
}
func TestMain(m *testing.M) {
if os.Getenv(extension.Handshake.MagicCookieKey) != "" {
goplugin.Serve(&goplugin.ServeConfig{
HandshakeConfig: extension.Handshake,
Plugins: goplugin.PluginSet{Surface: &Plugin{Impl: &echoEngine{}}},
GRPCServer: goplugin.DefaultGRPCServer,
})
return
}
os.Exit(m.Run())
}
func selfDigest(t *testing.T) string {
t.Helper()
binary, err := os.ReadFile(os.Args[0]) //nolint:gosec // G703: reads this test binary.
if err != nil {
t.Fatal(err)
}
sum := sha256.Sum256(binary)
return hex.EncodeToString(sum[:])
}
// lanAddress is a non-loopback IPv4 address of this machine. Without one the
// egress cases cannot run, and they fail rather than skip.
func lanAddress(t *testing.T) string {
t.Helper()
addrs, err := net.InterfaceAddrs()
if err != nil {
t.Fatal(err)
}
for _, a := range addrs {
if ip, ok := a.(*net.IPNet); ok && ip.IP.To4() != nil && !ip.IP.IsLoopback() {
return ip.IP.String()
}
}
t.Fatal("no non-loopback IPv4 address to stand in for an egress host")
return ""
}
func TestHostLaunch(t *testing.T) {
requireNamespaces(t)
t.Setenv("ARCHIE_TEST_SECRET", "host-only")
t.Setenv("ARCHIE_TEST_PASSED", "granted")
good := selfDigest(t)
// The egress gate refuses loopback, so the servers listen on this
// machine's network address, standing in for a private-network host.
lan := lanAddress(t)
serve := func() string {
ln, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", net.JoinHostPort(lan, "0"))
if err != nil {
t.Fatal(err)
}
srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { _, _ = io.WriteString(w, "reached") }))
srv.Listener = ln
srv.Start()
t.Cleanup(srv.Close)
return ln.Addr().String()
}
accepted, other := serve(), serve()
loopbackServer := httptest.NewServer(http.NotFoundHandler())
t.Cleanup(loopbackServer.Close)
loopback := loopbackServer.Listener.Addr().String()
tests := []struct {
name string
sha string
key string
want string
wantErr string
// open runs the package with no declared egress hosts.
open bool
}{
{name: "an accepted egress host is reachable through the proxy", sha: good, key: "GET:http://" + accepted, want: "reached"},
{name: "a host that was not accepted is refused", sha: good, key: "GET:http://" + other, want: "403 Forbidden"},
{name: "a direct connection bypassing the proxy fails", sha: good, key: "DIAL:" + accepted, want: "dial failed"},
{name: "a package declaring no egress hosts dials directly", sha: good, key: "DIAL:" + accepted, want: "connected", open: true},
{name: "loopback is refused even when accepted", sha: good, key: "GET:http://" + loopback, want: "502 Bad Gateway"},
{name: "settings reach the engine", sha: good, key: "color", want: "blue"},
{name: "an unknown key is not found", sha: good, key: "missing", wantErr: "not found"},
{name: "an env var outside the allowlist is invisible", sha: good, key: "ENV:ARCHIE_TEST_SECRET", want: ""},
{name: "an allowlisted env var is passed", sha: good, key: "ENV:ARCHIE_TEST_PASSED", want: "granted"},
{name: "a binary that does not match its digest is refused", sha: strings.Repeat("0", 64), wantErr: "checksum"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
host := extension.NewHost(slog.New(slog.DiscardHandler))
t.Cleanup(host.Close)
spec := extension.Spec{Name: "echo", Path: os.Args[0], SHA256: tt.sha, Env: []string{"ARCHIE_TEST_PASSED"}, Egress: []string{accepted, loopback}}
if tt.open {
spec.Egress = nil
}
engine, err := Start(context.Background(), host, spec, map[string]string{"color": "blue"})
if tt.sha != good {
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
t.Fatalf("Start error = %v, want %q", err, tt.wantErr)
}
return
}
if err != nil {
t.Fatal(err)
}
got, err := engine.Resolve(tt.key)
if tt.wantErr != "" {
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
t.Fatalf("Resolve error = %v, want %q", err, tt.wantErr)
}
return
}
if err != nil || got != tt.want {
t.Fatalf("Resolve(%q) = %q, %v; want %q", tt.key, got, err, tt.want)
}
})
}
}
type fakeSource struct {
settings controlplanerpc.ExtensionSettings
pkg storepkg.Installed
}
func (f *fakeSource) Query(_ context.Context, _ string, decode func([]byte) error) (int64, bool, error) {
raw, _ := json.Marshal(f.settings)
return 1, true, decode(raw)
}
func (f *fakeSource) ListInstalled(context.Context) ([]storepkg.Installed, error) {
listed := f.pkg
listed.Layer = nil
return []storepkg.Installed{listed}, nil
}
func (f *fakeSource) GetInstalled(context.Context, string) (storepkg.Installed, error) {
return f.pkg, nil
}
func layerOf(t *testing.T, name string, content []byte) []byte {
t.Helper()
var buf bytes.Buffer
w := tar.NewWriter(&buf)
if err := w.WriteHeader(&tar.Header{Name: name, Mode: 0o755, Size: int64(len(content)), Typeflag: tar.TypeReg}); err != nil {
t.Fatal(err)
}
if _, err := w.Write(content); err != nil {
t.Fatal(err)
}
if err := w.Close(); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
// An extension runs only while its package is accepted and the settings enable
// it, and stops the moment either stops being true.
func TestRunnerRunsOnlyWhatIsAcceptedAndEnabled(t *testing.T) {
binary, err := os.ReadFile(os.Args[0]) //nolint:gosec // G703: reads this test binary.
if err != nil {
t.Fatal(err)
}
source := &fakeSource{pkg: storepkg.Installed{
Name: "echo", Digest: "sha256:" + strings.Repeat("a", 64),
Descriptor: storepkg.Descriptor{Version: "1.2.3", Contributes: storepkg.Contributions{
Extensions: []storepkg.Extension{{Surface: storepkg.SurfaceSecretEngine, Path: "bin/echo"}},
}},
Layer: layerOf(t, "bin/echo", binary),
}}
registry := secret.NewRegistry()
host := extension.NewHost(slog.New(slog.DiscardHandler))
runner := NewRunner(host, registry, Source{Query: source, Packages: source}, t.TempDir(), slog.New(slog.DiscardHandler))
t.Cleanup(runner.Close)
ctx := context.Background()
changes := make(chan struct{}, 4)
runner.OnChange(func() { changes <- struct{}{} })
changed := func() bool {
select {
case <-changes:
return true
case <-time.After(time.Second):
return false
}
}
registered := func() bool { _, ok := registry.Get("echo"); return ok }
sync := func() {
t.Helper()
if err := runner.Sync(ctx); err != nil {
t.Fatal(err)
}
}
source.settings = controlplanerpc.ExtensionSettings{Extensions: []controlplanerpc.ExtensionSetting{{Name: "echo", Enabled: true, Settings: map[string]string{"k": "v"}}}}
sync()
if registered() {
t.Fatal("an extension whose authority was never accepted must not run")
}
if len(changes) > 0 {
t.Fatal("a sync that started nothing must not report a change")
}
source.pkg.AcceptedAuthority = &storepkg.Authority{}
sync()
got, err := registry.Resolve(secret.SecretRef{Engine: "echo", Key: "k"})
if err != nil || got != "v" {
t.Fatalf("accepted and enabled: Resolve = %q, %v; want v", got, err)
}
if !changed() {
t.Fatal("starting an engine must report a change, so references resolve again")
}
listed := registry.List()
if len(listed) != 2 || listed[0].Name != "echo" || listed[0].Version != "1.2.3" || listed[0].Source != "extension" || listed[1].Name != "env" || listed[1].Source != "built-in" {
t.Fatalf("registered engines: %+v", listed)
}
source.settings.Extensions[0].Enabled = false
sync()
if registered() || host.Alive("echo") {
t.Fatal("a disabled extension must be unregistered and its process stopped")
}
if listed := registry.List(); len(listed) != 1 || listed[0].Name != "env" {
t.Fatalf("disabled engine remains listed: %+v", listed)
}
if !changed() {
t.Fatal("stopping an engine must report a change")
}
}