Files
cairnobs/scripts/fleet/vault.go
T
jcoffey-dev db156c4f06
release / release (push) Successful in 7m6s
Cairn OBS
The new Cairn OBS: a self-hosted monitor for networks, hosts and
services. Licensed AGPLv3.
2026-11-14 03:27:09 -07:00

269 lines
11 KiB
Go

package main
import (
"context"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"encoding/hex"
"encoding/json"
"encoding/pem"
"errors"
"fmt"
"log"
"math"
"math/big"
"net"
"net/http"
"os"
"path/filepath"
"strings"
"time"
)
// Two Vault clusters obs-beacond reads itself (docs/vault.md: the fleet
// simulator), served over HTTPS on loopback:
//
// - vault-prod: Vault Enterprise, three healthy Raft servers, DR
// replication streaming to its secondary, a license 300 days out, an
// audit device, and a PKI mount (pki_int) with 400 services'
// certificates (some ending soon) and 2,000 short-lived ones.
// - vault-edge: OpenBao, three Raft servers with one failed (no failure
// tolerance left), and an intermediate CA 12 days from its end.
//
// They listen on vaultPort and the port after it; -vault's directory
// keeps their certificate and key, so vault.yaml (written there) stays
// the same across runs.
const vaultPort = 58310
type fakeVault struct {
name, version string
enterprise bool
servers []fakeRaft
ft int
mount string
issuer string // PEM
issuerID string
certs map[string]string // serial → PEM
serials []string
revoked []string
leases int
}
type fakeRaft struct{ id, status, node string }
func serveVaults(ctx context.Context, dir string) {
if err := os.MkdirAll(dir, 0o700); err != nil {
log.Fatal(err)
}
cert, fp, err := vaultTLS(dir)
if err != nil {
log.Fatalf("fleet: vault: %v", err)
}
tok := filepath.Join(dir, "token")
if err := os.WriteFile(tok, []byte("fleet-vault-token\n"), 0o600); err != nil {
log.Fatal(err)
}
now := time.Now()
vaults := []*fakeVault{
newFakeVault("vault-prod", "1.21.4+ent", true, "pki_int", now, 300*24*time.Hour, 400, 2000,
[]fakeRaft{{"v1", "leader", "alive"}, {"v2", "voter", "alive"}, {"v3", "voter", "alive"}}, 1, 18_000),
newFakeVault("vault-edge", "2.4.1", false, "pki_edge", now, 12*24*time.Hour, 40, 0,
[]fakeRaft{{"e1", "leader", "alive"}, {"e2", "voter", "alive"}, {"e3", "voter", "failed"}}, 0, 900),
}
var yaml strings.Builder
yaml.WriteString("vault:\n")
for i, v := range vaults {
ln, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", vaultPort+i))
if err != nil {
log.Fatal(err)
}
srv := &http.Server{Handler: v, TLSConfig: &tls.Config{Certificates: []tls.Certificate{cert}}, ReadHeaderTimeout: 5 * time.Second}
go func() { _ = srv.ServeTLS(ln, "", "") }()
go func() { <-ctx.Done(); _ = srv.Close() }()
fmt.Fprintf(&yaml, " - {name: %s, url: 'https://%s', token_file: %s, fingerprint: %s}\n", v.name, ln.Addr(), tok, fp)
log.Printf("fleet: Vault %s (%s) at https://%s: %d certificates on %s", v.name, v.version, ln.Addr(), len(v.serials), v.mount)
}
p := filepath.Join(dir, "vault.yaml")
if err := os.WriteFile(p, []byte(yaml.String()), 0o600); err != nil {
log.Fatal(err)
}
log.Printf("fleet: %s has the vault: list for obs-beacond.yaml", p)
}
// vaultTLS is the fake Vaults' certificate, made once and kept in dir.
func vaultTLS(dir string) (tls.Certificate, string, error) {
cp, kp := filepath.Join(dir, "tls.crt"), filepath.Join(dir, "tls.key")
if _, err := os.Stat(cp); errors.Is(err, os.ErrNotExist) {
key, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tpl := &x509.Certificate{SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "fleet vault"}, DNSNames: []string{"localhost"},
IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(10 * 365 * 24 * time.Hour)}
der, err := x509.CreateCertificate(rand.Reader, tpl, tpl, &key.PublicKey, key)
if err != nil {
return tls.Certificate{}, "", err
}
kb, _ := x509.MarshalECPrivateKey(key)
_ = os.WriteFile(cp, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}), 0o600)
_ = os.WriteFile(kp, pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: kb}), 0o600)
}
c, err := tls.LoadX509KeyPair(cp, kp)
if err != nil {
return c, "", err
}
sum := sha256.Sum256(c.Certificate[0])
return c, hex.EncodeToString(sum[:]), nil
}
// newFakeVault makes a cluster with an intermediate CA ending caLeft from
// now, a year's certificates for that many services (most renewed once)
// and short ones lasting an hour.
func newFakeVault(name, version string, ent bool, mount string, now time.Time, caLeft time.Duration, services, short int,
servers []fakeRaft, ft, leases int) *fakeVault {
v := &fakeVault{name: name, version: version, enterprise: ent, servers: servers, ft: ft, mount: mount, certs: map[string]string{},
issuerID: "4f6c1e2a-0000-4000-8000-" + fmt.Sprintf("%012d", len(name)), leases: leases}
caKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
n := int64(1000)
sign := func(tpl *x509.Certificate, parent *x509.Certificate, pub any, by *ecdsa.PrivateKey) (*x509.Certificate, string) {
n++
tpl.SerialNumber = big.NewInt(n)
if parent == nil {
parent = tpl
}
der, err := x509.CreateCertificate(rand.Reader, tpl, parent, pub, by)
if err != nil {
log.Fatal(err)
}
x, _ := x509.ParseCertificate(der)
return x, string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}))
}
ca, caPEM := sign(&x509.Certificate{Subject: pkix.Name{CommonName: name + " Intermediate CA"}, IsCA: true, BasicConstraintsValid: true,
KeyUsage: x509.KeyUsageCertSign, NotBefore: now.Add(-3 * 365 * 24 * time.Hour), NotAfter: now.Add(caLeft)}, nil, &caKey.PublicKey, caKey)
v.issuer = caPEM
add := func(x *x509.Certificate, p string) {
s := serialHex(x)
v.certs[s], v.serials = p, append(v.serials, s)
}
add(ca, caPEM)
leafKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
day := 24 * time.Hour
for i := range services {
cn := fmt.Sprintf("svc-%03d.%s.internal", i, strings.TrimPrefix(name, "vault-"))
// Most a long way from their end; a few within the warning's 21
// days, fewer within the critical 7.
left := time.Duration(25+(i*37)%340) * day
switch {
case i%97 == 5:
left = 5 * day
case i%41 == 7:
left = 15 * day
}
for k, end := range []time.Duration{left - 30*day, left} { // the one it replaced, then the renewal
x, p := sign(&x509.Certificate{Subject: pkix.Name{CommonName: cn}, DNSNames: []string{cn}, NotBefore: now.Add(end - 365*day), NotAfter: now.Add(end)},
ca, &leafKey.PublicKey, caKey)
if k == 0 && end < -8*day {
continue // tidied away
}
add(x, p)
}
}
for i := range short {
cn := fmt.Sprintf("job-%04d.batch.internal", i)
start := now.Add(-time.Duration(i%60) * time.Minute)
x, p := sign(&x509.Certificate{Subject: pkix.Name{CommonName: cn}, DNSNames: []string{cn}, NotBefore: start, NotAfter: start.Add(time.Hour)}, ca, &leafKey.PublicKey, caKey)
add(x, p)
}
if len(v.serials) > 5 {
v.revoked = []string{v.serials[3]}
}
return v
}
func serialHex(x *x509.Certificate) string {
b := x.SerialNumber.Bytes()
parts := make([]string, len(b))
for i, c := range b {
parts[i] = fmt.Sprintf("%02x", c)
}
return strings.Join(parts, ":")
}
func (v *fakeVault) ServeHTTP(w http.ResponseWriter, r *http.Request) {
p := strings.TrimPrefix(r.URL.Path, "/v1/")
list := r.Method == "LIST" || r.URL.Query().Get("list") == "true"
now := time.Now()
var out any
data := func(d any) any { return map[string]any{"data": d} }
switch {
case p == "sys/health":
mode := "disabled"
if v.enterprise {
mode = "primary"
}
out = map[string]any{"initialized": true, "sealed": false, "standby": false, "version": v.version, "cluster_name": v.name,
"enterprise": v.enterprise, "replication_dr_mode": mode, "replication_performance_mode": "disabled"}
case p == "sys/leader":
out = map[string]any{"ha_enabled": true, "is_self": true, "leader_address": "https://" + v.servers[0].id + "." + v.name + ":8200"}
case p == "sys/storage/raft/autopilot/state":
servers, voters, healthy := map[string]any{}, []string{}, true
for _, s := range v.servers {
ok := s.node == "alive"
healthy = healthy && ok
sv := map[string]any{"id": s.id, "name": v.name + "-" + s.id, "address": s.id + ":8201", "node_status": s.node, "healthy": ok,
"status": s.status, "last_contact": "0s", "version": strings.TrimSuffix(v.version, "+ent"), "stable_since": now.Add(-40 * 24 * time.Hour).Format(time.RFC3339)}
if !ok {
sv["last_contact"] = "41m12s"
}
servers[s.id] = sv
voters = append(voters, s.id)
}
out = data(map[string]any{"healthy": healthy, "failure_tolerance": v.ft, "voters": voters, "servers": servers})
case p == "auth/token/lookup-self":
out = data(map[string]any{"display_name": "token-obs-beacond", "policies": []string{"default", "obs-monitor"}, "ttl": 20 * 3600,
"creation_ttl": 24 * 3600, "renewable": true, "type": "service"})
case p == "auth/token/renew-self":
out = map[string]any{"auth": map[string]any{"lease_duration": 24 * 3600}}
case p == "sys/metrics":
l := v.leases + int(float64(v.leases)/10*math.Sin(float64(now.Unix())/3600))
fmt.Fprintf(w, "# TYPE vault_expire_num_leases gauge\nvault_expire_num_leases %d\nvault_expire_num_irrevocable_leases 0\n", l)
if v.enterprise {
fmt.Fprint(w, "vault_audit_log_request_failure 0\nvault_audit_log_response_failure 0\n")
}
return
case p == "sys/mounts":
out = data(map[string]any{v.mount + "/": map[string]any{"type": "pki"}, "secret/": map[string]any{"type": "kv"}})
case p == "sys/replication/status" && v.enterprise:
out = data(map[string]any{"dr": map[string]any{"mode": "primary", "state": "running", "known_secondaries": []string{"dr-west"}, "last_wal": 912_334,
"secondaries": []any{map[string]any{"node_id": "dr-west", "api_address": "https://vault-dr.west:8200", "connection_state": "ready",
"last_heartbeat": now.Add(-4 * time.Second).Format(time.RFC3339)}}}, "performance": map[string]any{"mode": "disabled"}})
case p == "sys/license/status" && v.enterprise:
out = data(map[string]any{"autoloading_used": true, "autoloaded": map[string]any{"license_id": "fleet-0000",
"expiration_time": now.Add(300 * 24 * time.Hour).Format(time.RFC3339), "termination_time": now.Add(310 * 24 * time.Hour).Format(time.RFC3339)}})
case p == v.mount+"/issuers" && list:
out = data(map[string]any{"keys": []string{v.issuerID}})
case p == v.mount+"/issuer/"+v.issuerID:
out = data(map[string]any{"certificate": v.issuer, "issuer_name": "intermediate-2023"})
case p == v.mount+"/certs" && list:
out = data(map[string]any{"keys": v.serials})
case p == v.mount+"/certs/revoked" && list:
out = data(map[string]any{"keys": v.revoked})
case strings.HasPrefix(p, v.mount+"/cert/"):
c, ok := v.certs[strings.TrimPrefix(p, v.mount+"/cert/")]
if !ok {
w.WriteHeader(http.StatusNotFound)
out = map[string]any{"errors": []string{}}
break
}
out = data(map[string]any{"certificate": c})
default:
w.WriteHeader(http.StatusNotFound)
out = map[string]any{"errors": []string{}}
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(out)
}