Files
archie/internal/secret/engine.go
T
sam bc430fa50d fix(secret): recover a panicking secret engine instead of crashing
Registry.Resolve and Getenv called engine.Resolve directly with no panic
recovery, so a defective interpreted engine (sops/Vault plugin) took the
whole daemon down at boot when resolving a provider credential
(provider_secrets.go's only caller has no recovery of its own). Wrap both
call sites in yaegiutil.Safe, the same recovery every other Yaegi
extension surface in this repo already uses.
2026-09-15 04:38:51 +10:00

208 lines
6.7 KiB
Go

// Package secret provides a pluggable secrets-engine registry. Engines
// resolve SecretRef values (engine + key) into strings at daemon startup,
// keeping credentials out of config files and serialized worker contracts.
//
// The "env" and "bws" engines are compiled in. Other backends (sops,
// Vault/OpenBao) may ship as Yaegi-loaded .go plugins under a configurable
// directory via Registry.LoadDir, mirroring internal/plugin conventions.
package secret
import (
"fmt"
"log/slog"
"os"
"path/filepath"
"reflect"
"sort"
"strings"
"sync"
"github.com/traefik/yaegi/interp"
"github.com/samcharles93/archie-core/internal/yaegiutil"
)
// safeResolve calls e.Resolve(key) with panic recovery. An interpreted
// (Yaegi-loaded) engine is untrusted relative to the daemon's own
// logic: a defect in the engine itself must degrade the credential it
// was resolving, not crash the process that's resolving it -- e.g. at
// boot, in internal/app/archied/provider_secrets.go.
func safeResolve(e Engine, key string) (string, error) {
return yaegiutil.Safe(e.Name(), func() (string, error) {
return e.Resolve(key)
})
}
// Engine resolves secret references into their plaintext values.
// Implementations must be safe for concurrent use.
type Engine interface {
// Name returns a unique engine identifier (e.g. "env", "bws", "sops").
Name() string
// Version returns a semver string for dependency tracking.
Version() string
// Resolve looks up a secret by key and returns its value. Returns an
// error when the key is unknown or the backend is unreachable.
//
// Caution for callers: a Yaegi-loaded engine whose exported value
// omits the Resolve function resolves every key to ("", nil) rather
// than failing (see secretextract's generated wrapper nil-guards) --
// check for an empty string in addition to a non-nil error before
// trusting a resolved secret.
Resolve(key string) (string, error)
}
// Registry holds all loaded secret engines. The zero value is usable.
type Registry struct {
mu sync.RWMutex
engines map[string]Engine // name → engine
}
// Register adds an engine. If an engine with the same name already
// exists, it is replaced (last-write-wins for overrides).
func (r *Registry) Register(e Engine) {
r.mu.Lock()
defer r.mu.Unlock()
if r.engines == nil {
r.engines = make(map[string]Engine)
}
r.engines[e.Name()] = e
}
// Get returns the engine with the given name, or false when not found.
func (r *Registry) Get(name string) (Engine, bool) {
r.mu.RLock()
defer r.mu.RUnlock()
e, ok := r.engines[name]
return e, ok
}
// Getenv resolves an environment-shaped secret name. The real process
// environment wins; registered external engines are tried in stable name
// order. A resolved value is exported so SDKs and child processes that accept
// only environment-variable credentials observe the same secret.
func (r *Registry) Getenv(key string) string {
if value := os.Getenv(key); value != "" {
return value
}
r.mu.RLock()
names := make([]string, 0, len(r.engines))
for name := range r.engines {
if name != "env" {
names = append(names, name)
}
}
sort.Strings(names)
engines := make([]Engine, 0, len(names))
for _, name := range names {
engines = append(engines, r.engines[name])
}
r.mu.RUnlock()
for _, engine := range engines {
value, err := safeResolve(engine, key)
value = strings.TrimSpace(value)
if err != nil || value == "" {
continue
}
if err := os.Setenv(key, value); err != nil {
return ""
}
return value
}
return ""
}
// Resolve resolves a SecretRef through the registered engine. The zero
// value (engine and key both empty) resolves to "" with no error -- the
// zero value means "not configured".
func (r *Registry) Resolve(ref SecretRef) (string, error) {
if ref.Engine == "" && ref.Key == "" {
return "", nil
}
e, ok := r.Get(ref.Engine)
if !ok {
return "", fmt.Errorf("secret engine %q not registered", ref.Engine)
}
return safeResolve(e, ref.Key)
}
// LoadDir discovers and evaluates .go files in dir. Each file must export
// a variable named "Engine" that implements the Engine interface. Failed
// engines are logged and skipped -- the daemon starts with the remaining
// set, matching internal/plugin.LoadDir's degrade-gracefully behavior.
// Returns the count of newly registered engines.
//
// extraSymbols are additional Yaegi symbol tables made available to
// interpreted code. Callers should pass secretextract.Symbols so that
// interpreted types can satisfy the secret.Engine interface across the
// Yaegi/Go boundary, and enginehost.Symbols so plugins can run CLIs with
// a real host environment (yaegi's interpreted os/exec cannot pass env
// to children). See cmd/archied/provider_secrets.go for the production
// wiring.
func (r *Registry) LoadDir(dir string, extraSymbols ...map[string]map[string]reflect.Value) (int, error) {
entries, err := os.ReadDir(dir)
if os.IsNotExist(err) {
return 0, nil
}
if err != nil {
return 0, fmt.Errorf("secret: read dir %s: %w", dir, err)
}
var names []string
for _, e := range entries {
if !e.IsDir() && strings.HasSuffix(e.Name(), ".go") {
names = append(names, e.Name())
}
}
sort.Strings(names)
loaded := 0
for _, name := range names {
path := filepath.Join(dir, name)
src, err := os.ReadFile(path)
if err != nil {
slog.Default().Warn("skipping unreadable secret engine", "file", name, "err", err)
continue
}
// Each file is package main -- must use a fresh interpreter to
// avoid symbol collisions between files.
// The interpreter is seeded with the host environment: yaegi's
// interpreted os package keeps a private env otherwise, so
// plugins reading SOPS_FILE/VAULT_*/AGE_* via os.Getenv would
// silently see nothing.
i, err := yaegiutil.New(interp.Options{Env: os.Environ()}, extraSymbols...)
if err != nil {
slog.Default().Warn("skipping secret engine -- interpreter setup failed", "file", name, "err", err)
continue
}
e, err := yaegiutil.Resolve[Engine](i, string(src), "main.Engine")
if err != nil {
slog.Default().Warn("skipping secret engine", "file", name, "err", err)
continue
}
r.Register(e)
loaded++
}
return loaded, nil
}
// DefaultRegistry returns a singleton pre-loaded with the built-in env engine.
// Use this when you need a one-off secret resolution without threading a
// Registry through the entire call stack.
func DefaultRegistry() *Registry {
return defaultReg
}
var defaultReg = &Registry{engines: map[string]Engine{
"env": &envEngine{},
"bws": newBWSEngine(),
}}
// NewRegistry creates a Registry pre-loaded with the built-in env and
// Bitwarden Secrets Manager engines.
func NewRegistry() *Registry {
r := &Registry{engines: make(map[string]Engine)}
r.Register(&envEngine{})
r.Register(newBWSEngine())
return r
}