Files

141 lines
3.9 KiB
Go

// Package secret provides a pluggable secrets-engine registry. Engines
// resolve SecretRef values (engine + key) into strings, keeping credentials
// out of config files and serialized worker contracts.
//
// Only the "env" engine is compiled in. Every other backend is an extension
// served over the secretengine.v1 gRPC surface and registered here while it
// is enabled.
package secret
import (
"fmt"
"os"
"sort"
"strings"
"sync"
)
// 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
// Resolve looks up a secret by key and returns its value. Returns an
// error when the key is unknown or the backend is unreachable.
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
}
// EngineInfo describes an installed engine without exposing credentials.
type EngineInfo struct {
Name string `json:"name"`
Version string `json:"version,omitempty"`
Source string `json:"source"`
}
func (r *Registry) List() []EngineInfo {
r.mu.RLock()
defer r.mu.RUnlock()
out := make([]EngineInfo, 0, len(r.engines))
for name, engine := range r.engines {
info := EngineInfo{Name: name, Source: "extension"}
if _, ok := engine.(*envEngine); ok {
info.Source = "built-in"
}
if versioned, ok := engine.(interface{ Version() string }); ok {
info.Version = versioned.Version()
}
out = append(out, info)
}
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
return out
}
// 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 := engine.Resolve(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 e.Resolve(ref.Key)
}
// Unregister removes the named engine. Removing one that is not registered is
// not an error.
func (r *Registry) Unregister(name string) {
r.mu.Lock()
defer r.mu.Unlock()
delete(r.engines, name)
}
// NewRegistry creates a Registry holding the built-in env engine.
func NewRegistry() *Registry {
r := &Registry{engines: make(map[string]Engine)}
r.Register(&envEngine{})
return r
}