docs/prds/plugin-settings-live.md: a `plugin-settings` change now applies live for plugin_dir, module_dir and secret_engine_dir, and a file dropped into any of those directories loads on the reconciliation tick. - PluginSettingsKind moves to ApplyMode "live" and joins runtimeResourceKinds, so a stored directory change re-layers immediately. - A reconciler re-runs the directory loads and the layering on the apply-status restamp interval. Files are content-hashed, so only new and changed files load. - plugin.Host grows Add and Replace for the running state (Register keeps its pre-Start rule), and plugin.LoadFile / secret.Registry.LoadFile are the single-file load paths the boot loader and the reconciler share. - Yaegi cannot unload, so a removed file keeps running and the removal is reported through apply status against the live version until restart; a clean pass clears it. - A plugin-settings document that changes skills_dir is refused before the layering, since skills_dir has no live consumer. - applystatus.Reporter.AppliedVersion lets the reconciliation report an outcome without resetting the version to zero.
215 lines
7.0 KiB
Go
215 lines
7.0 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 {
|
|
if err := r.LoadFile(filepath.Join(dir, name), extraSymbols...); err != nil {
|
|
slog.Default().Warn("skipping secret engine", "file", name, "err", err)
|
|
continue
|
|
}
|
|
loaded++
|
|
}
|
|
return loaded, nil
|
|
}
|
|
|
|
// LoadFile evaluates one secret-engine file and registers the engine it
|
|
// exports. Each file is package main and needs a fresh interpreter to avoid
|
|
// symbol collisions, so the boot load (LoadDir) and a live directory
|
|
// reconciliation both load through here rather than through two copies of the
|
|
// interpreter setup.
|
|
//
|
|
// The interpreter is seeded with the host environment: yaegi's interpreted os
|
|
// package keeps a private env otherwise, so an engine reading
|
|
// SOPS_FILE/VAULT_*/AGE_* via os.Getenv would silently see nothing.
|
|
func (r *Registry) LoadFile(path string, extraSymbols ...map[string]map[string]reflect.Value) error {
|
|
src, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return fmt.Errorf("secret: read %s: %w", path, err)
|
|
}
|
|
i, err := yaegiutil.New(interp.Options{Env: os.Environ()}, extraSymbols...)
|
|
if err != nil {
|
|
return fmt.Errorf("secret: %s: interpreter setup: %w", path, err)
|
|
}
|
|
e, err := yaegiutil.Resolve[Engine](i, string(src), "main.Engine")
|
|
if err != nil {
|
|
return fmt.Errorf("secret: %s: %w", path, err)
|
|
}
|
|
r.Register(e)
|
|
return 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
|
|
}
|