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.
208 lines
6.7 KiB
Go
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
|
|
}
|