141 lines
3.9 KiB
Go
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
|
|
}
|