Adds internal/secret: a pluggable Engine interface (Name/Version/Resolve)
resolved through a Registry, so secrets backends (sops, Bitwarden Secrets
Manager, Vault/OpenBao) aren't hard-coded into the binary. Only the "env"
engine is compiled in; custom engines are Yaegi-interpreted .go plugins
loaded via Registry.LoadDir, mirroring internal/plugin's conventions
(secretextract provides the generated, nil-guarded symbol table for the
Yaegi/Go interface boundary).
config.Forge.TokenEnv is replaced end-to-end with config.Forge.Token
(secret.SecretRef{Engine, Key}) -- finalize() defaulting, forge token
resolution in cmd/archied/main.go, and per-identity validation that now
requires an explicit token instead of silently resolving to "". No
backwards-compat shim.
Provider.APIKeyEnv, NATSConfig.TokenEnv, and TelegramConfig.TokenEnv are
deliberately not migrated here -- they're forwarded by name to
ai-sdk/runtime and subprocess workers rather than resolved centrally,
which needs its own eager-resolve-then-inject design pass
(archie-core-xec.4). The three shipped engine plugins (sops, bws,
vault/openbao) are tracked separately as archie-core-xec.1-3.
Adversarially reviewed by a fresh agent with no implementation context;
fixed the two findings that survived (missing per-identity token
validation, underdocumented nil-wrapper Resolve edge case).
359 lines
9.2 KiB
Go
359 lines
9.2 KiB
Go
package secret_test
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
"github.com/samcharles93/archie-core/internal/secret/secretextract"
|
|
)
|
|
|
|
// ── LoadDir behavioral tests ─────────────────────────────────────────
|
|
|
|
var symbols = secretextract.Symbols
|
|
|
|
func TestLoadDirLoadsValidEngine(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "hello.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "hello" },
|
|
WVersion: func() string { return "1.0.0" },
|
|
WResolve: func(key string) (string, error) { return "resolved:" + key, nil },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatalf("LoadDir returned %d, want 1", n)
|
|
}
|
|
e, ok := r.Get("hello")
|
|
if !ok {
|
|
t.Fatal("engine \"hello\" not registered")
|
|
}
|
|
if e.Version() != "1.0.0" {
|
|
t.Errorf("Version() = %q, want 1.0.0", e.Version())
|
|
}
|
|
v, err := e.Resolve("k")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v != "resolved:k" {
|
|
t.Errorf("Resolve() = %q, want resolved:k", v)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSkipsInvalidEngine(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "broken.go"), []byte(`package main
|
|
this is not valid Go syntax @@@@
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("LoadDir returned %d from broken source, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSkipsFileWithoutEngineExport(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "notanengine.go"), []byte(`package main
|
|
|
|
func Something() string { return "nope" }
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("LoadDir returned %d from file without Engine export, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSkipsNonGoFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "readme.md"), []byte(`# Not an engine`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "hello.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "hello" },
|
|
WVersion: func() string { return "1.0.0" },
|
|
WResolve: func(key string) (string, error) { return "v", nil },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatalf("LoadDir returned %d, want 1 (only .go files count)", n)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSubdirectoriesAreIgnored(t *testing.T) {
|
|
dir := t.TempDir()
|
|
subDir := filepath.Join(dir, "nested")
|
|
if err := os.MkdirAll(subDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(subDir, "nested.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "nested" },
|
|
WVersion: func() string { return "1.0.0" },
|
|
WResolve: func(key string) (string, error) { return "v", nil },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("LoadDir returned %d, want 0 -- subdirectories must not be traversed", n)
|
|
}
|
|
}
|
|
|
|
// ── Adversarial tests ────────────────────────────────────────────────
|
|
|
|
func TestLoadDirNilFunctionFieldsLoadsWithoutPanic(t *testing.T) {
|
|
// A _Engine with nil WName/WVersion/WResolve must LOAD without
|
|
// panicking AND must not panic when called -- the wrapper must
|
|
// nil-guard. Otherwise resolving a secret from a malformed custom
|
|
// engine crashes the daemon.
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "nilfuncs.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: nil,
|
|
WVersion: nil,
|
|
WResolve: nil,
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatalf("LoadDir returned %d, want 1 (nil funcs should not prevent loading)", n)
|
|
}
|
|
|
|
e, _ := r.Get("")
|
|
if name := e.Name(); name != "" {
|
|
t.Errorf("Name() = %q, want empty from nil WName", name)
|
|
}
|
|
if version := e.Version(); version != "" {
|
|
t.Errorf("Version() = %q, want empty from nil WVersion", version)
|
|
}
|
|
if v, err := e.Resolve("k"); err != nil || v != "" {
|
|
t.Errorf("Resolve() = (%q, %v), want (\"\", nil) from nil WResolve", v, err)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSkipsEngineWithWrongExportType(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "wrongtype.go"), []byte(`package main
|
|
|
|
var Engine = 42
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("LoadDir returned %d from wrong-type export, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirSkipsEngineWithOnlySomeInterfaceMethods(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "partial.go"), []byte(`package main
|
|
|
|
type partial struct{}
|
|
func (p partial) Name() string { return "partial" }
|
|
func (p partial) Version() string { return "1.0.0" }
|
|
// No Resolve() method -- deliberately incomplete.
|
|
|
|
var Engine partial
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("LoadDir returned %d from partial impl, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestLoadDirEngineWithPanicInResolve(t *testing.T) {
|
|
// An engine whose Resolve() panics must still be loadable -- the
|
|
// panic only fires on call, not on load. Registry.Resolve does not
|
|
// itself recover; callers that invoke a loaded engine's Resolve are
|
|
// expected to use yaegiutil.Safe if they need panic recovery, same
|
|
// as internal/plugin callers.
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "panicky.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "panicky" },
|
|
WVersion: func() string { return "1.0.0" },
|
|
WResolve: func(key string) (string, error) { panic("boom") },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatalf("LoadDir returned %d, want 1 (panics are deferred to call time)", n)
|
|
}
|
|
|
|
e, _ := r.Get("panicky")
|
|
func() {
|
|
defer func() {
|
|
if rec := recover(); rec == nil {
|
|
t.Error("Resolve() did not panic -- expected panic from panicky engine")
|
|
}
|
|
}()
|
|
_, _ = e.Resolve("k")
|
|
}()
|
|
}
|
|
|
|
func TestLoadDirMultipleEnginesSortedByFilename(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "01-alpha.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "alpha" },
|
|
WVersion: func() string { return "1.0.0" },
|
|
WResolve: func(key string) (string, error) { return "v", nil },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "02-beta.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: func() string { return "beta" },
|
|
WVersion: func() string { return "2.0.0" },
|
|
WResolve: func(key string) (string, error) { return "v", nil },
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 2 {
|
|
t.Fatalf("LoadDir returned %d, want 2", n)
|
|
}
|
|
if _, ok := r.Get("alpha"); !ok {
|
|
t.Error("alpha engine not registered")
|
|
}
|
|
if _, ok := r.Get("beta"); !ok {
|
|
t.Error("beta engine not registered")
|
|
}
|
|
}
|
|
|
|
func TestGeneratedWrapperHasNilGuards(t *testing.T) {
|
|
// If go generate is re-run on secretextract, it overwrites the
|
|
// generated wrapper with Yaegi's default (no nil-guards). This test
|
|
// fails loudly if that happens -- a custom engine that omits
|
|
// WResolve would otherwise panic the daemon on first secret lookup.
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "nilguard.go"), []byte(`package main
|
|
|
|
import "github.com/samcharles93/archie-core/internal/secret"
|
|
|
|
var Engine = secret._Engine{
|
|
WName: nil,
|
|
WVersion: nil,
|
|
WResolve: nil,
|
|
}
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r := secret.NewRegistry()
|
|
n, err := r.LoadDir(dir, symbols)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatal("engine with nil funcs not loaded")
|
|
}
|
|
|
|
e, _ := r.Get("")
|
|
func() {
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
t.Fatalf("Name()/Version()/Resolve() panicked with nil funcs -- "+
|
|
"the generated _Engine wrapper is missing nil guards. "+
|
|
"Re-run of `go generate` may have overwritten them: %v", rec)
|
|
}
|
|
}()
|
|
_ = e.Name()
|
|
_ = e.Version()
|
|
_, _ = e.Resolve("k")
|
|
}()
|
|
}
|