0
0
package vaultmain
import (
"context"
"crypto/tls"
"errors"
"fmt"
"log/slog"
"net/http"
"os"
"reflect"
"strings"
"time"
"k8s.io/client-go/rest"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpserver"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
"github.com/johnandersen777/socialweb-computer-kcp/internal/openbaoctl"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vault/openbao"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vaultlayout"
)
const (
pkiRootCommonName = "socialweb.local"
pkiRootTTL = 8760 * time.Hour
)
type RootAccess struct {
Server string
Address string
CAFile string
ClientCert string
ClientKey string
CertMount string
CertRole string
}
func RootAccessOf(o v1alpha1.OpenBaoServer) (RootAccess, error) {
if o.Status.Phase != v1alpha1.OpenBaoServerPhaseReady || o.Status.Address == "" {
return RootAccess{}, fmt.Errorf("the OpenBaoServer %s is %s (%s), not Ready", o.Name, o.Status.Phase, o.Status.Message)
}
a := RootAccess{Server: o.Name, Address: o.Status.Address, CertMount: openbaoctl.CertAuthMount}
if o.Status.Refs != nil {
a.CAFile = openbaoctl.FileRef(o.Status.Refs.CA)
}
for _, c := range o.Status.Clients {
if c.Name != vaultlayout.RootClient {
continue
}
a.ClientCert, a.ClientKey, a.CertRole = openbaoctl.FileRef(c.ClientCert), openbaoctl.FileRef(c.ClientKey), c.CertAuthRole
if c.CertAuthMount != "" {
a.CertMount = c.CertAuthMount
}
}
if a.CAFile == "" || a.ClientCert == "" || a.ClientKey == "" || a.CertRole == "" {
return RootAccess{}, fmt.Errorf("the OpenBaoServer %s reports no CA or no client %s", o.Name, vaultlayout.RootClient)
}
return a, nil
}
func ReadRootAccess(ctx context.Context, kubeconfig, workspace, server string) (RootAccess, error) {
restCfg, err := kcpserver.FrontRestConfig(kubeconfig)
if err != nil {
return RootAccess{}, err
}
cfg := rest.CopyConfig(restCfg)
cfg.Host = strings.TrimSuffix(cfg.Host, "/") + "/clusters/" + workspace
kc, err := kube.New(cfg)
if err != nil {
return RootAccess{}, err
}
o, err := kube.Get[v1alpha1.OpenBaoServer](ctx, kc.Resource(openbaoctl.GVR), server)
if err != nil {
return RootAccess{}, fmt.Errorf("the root vault's OpenBaoServer %s in %s: %w", server, workspace, err)
}
return RootAccessOf(*o)
}
func (a RootAccess) Client(ctx context.Context) (*openbao.Client, error) {
raw, err := os.ReadFile(a.CAFile)
if err != nil {
return nil, fmt.Errorf("the root vault's TLS CA: %w", err)
}
pool, err := openbao.CertPoolFromPEM(raw)
if err != nil {
return nil, err
}
pair, err := tls.LoadX509KeyPair(a.ClientCert, a.ClientKey)
if err != nil {
return nil, fmt.Errorf("the client certificate of %s: %w", vaultlayout.RootClient, err)
}
base := openbao.New(a.Address, "", openbao.WithCACertPool(pool), openbao.WithClientCertificate(pair))
client, err := base.LoginCert(ctx, a.CertMount, a.CertRole)
if err != nil {
return nil, fmt.Errorf("logging in to the root vault at %s as %s: %w", a.Address, a.CertRole, err)
}
return client, nil
}
func pkiRootPresent(ctx context.Context, c *openbao.Client, mount string) (bool, error) {
_, err := c.CAPEM(ctx, mount)
if err == nil {
return true, nil
}
var re *openbao.ResponseError
if errors.As(err, &re) {
lower := strings.ToLower(re.Body)
if re.Status == http.StatusNoContent || re.Status == http.StatusNotFound || strings.Contains(lower, "no ca") ||
strings.Contains(lower, "not found") || strings.Contains(lower, "no certificate") {
return false, nil
}
}
if strings.Contains(err.Error(), "holds no certificate") {
return false, nil
}
return false, err
}
func ApplyRoot(ctx context.Context, a RootAccess, cfg Config, log *slog.Logger) error {
c, err := a.Client(ctx)
if err != nil {
return err
}
if err := ensurePKIRoot(ctx, c, log); err != nil {
return err
}
return applySecrets(ctx, c, cfg, log)
}
func ensurePKIRoot(ctx context.Context, c *openbao.Client, log *slog.Logger) error {
for _, m := range vaultlayout.Default().Mounts {
if m.Vault != vaultlayout.Root || m.Kind != vaultlayout.MountPKI {
continue
}
present, err := pkiRootPresent(ctx, c, m.Path)
if err != nil {
return err
}
if present {
log.Info("pki root already generated", "mount", m.Path)
continue
}
ttl := m.MaxLeaseTTL
ttl = opt.Positive(ttl, pkiRootTTL)
cert, err := c.GeneratePKIRoot(ctx, m.Path, pkiRootCommonName, ttl.String())
if err != nil {
return fmt.Errorf("generating the root CA under %s: %w", m.Path, err)
}
log.Info("generated the pki root", "mount", m.Path, "common_name", pkiRootCommonName, "serial", cert.Serial)
}
return nil
}
type sourcedSecret struct {
Path string
Data map[string]any
Reason string
Required bool
}
func planRootSecrets(ctx context.Context, c *openbao.Client, cfg Config) []sourcedSecret {
var out []sourcedSecret
for _, s := range vaultlayout.Default().Secrets {
if s.Vault != vaultlayout.Root {
continue
}
switch s.Class {
case vaultlayout.ClassKCPAdminKubeconfig:
raw, err := os.ReadFile(cfg.KCPKubeconfig)
if err != nil {
out = append(out, sourcedSecret{Path: s.Path, Required: true, Reason: err.Error()})
continue
}
out = append(out, sourcedSecret{Path: s.Path, Data: map[string]any{"kubeconfig": string(raw)}})
case vaultlayout.ClassKCPAdminTokenStore:
data, err := kcpAdminTokenStoreData(cfg)
if err != nil {
out = append(out, sourcedSecret{Path: s.Path, Required: true, Reason: err.Error()})
continue
}
out = append(out, sourcedSecret{Path: s.Path, Data: data})
case vaultlayout.ClassKCPClientCA:
pem, err := c.CAPEM(ctx, vaultlayout.MountPKIRoot)
if err != nil {
out = append(out, sourcedSecret{Path: s.Path, Required: true, Reason: err.Error()})
continue
}
out = append(out, sourcedSecret{Path: s.Path, Data: map[string]any{"ca.crt": strings.TrimSpace(pem)}})
case vaultlayout.ClassContainerTLS:
if cfg.TLSCert == "" || cfg.TLSKey == "" {
out = append(out, sourcedSecret{Path: s.Path, Reason: "the TLS front names no certificate"})
continue
}
cert, cerr := os.ReadFile(cfg.TLSCert)
key, kerr := os.ReadFile(cfg.TLSKey)
if err := errors.Join(cerr, kerr); err != nil {
out = append(out, sourcedSecret{Path: s.Path, Reason: err.Error()})
continue
}
out = append(out, sourcedSecret{Path: s.Path, Data: map[string]any{"tls.crt": string(cert), "tls.key": string(key)}})
default:
out = append(out, sourcedSecret{Path: s.Path, Required: true, Reason: fmt.Sprintf("class %s has no producer", s.Class)})
}
}
return out
}
func applySecrets(ctx context.Context, c *openbao.Client, cfg Config, log *slog.Logger) error {
for _, s := range planRootSecrets(ctx, c, cfg) {
if s.Data == nil {
if s.Required {
return fmt.Errorf("the root secret at %s has no source: %s", s.Path, s.Reason)
}
log.Warn("root secret not written", "path", s.Path, "reason", s.Reason)
continue
}
changed, err := putIfChanged(ctx, c, s.Path, s.Data)
if err != nil {
return fmt.Errorf("writing %s: %w", s.Path, err)
}
if changed {
log.Info("wrote root secret", "path", s.Path, "keys", keysOf(s.Data))
} else {
log.Info("root secret already current", "path", s.Path)
}
}
return nil
}
func putIfChanged(ctx context.Context, c *openbao.Client, path string, data map[string]any) (bool, error) {
existing, err := c.GetKV(ctx, path)
if err == nil && reflect.DeepEqual(existing, data) {
return false, nil
}
if err != nil && !errors.Is(err, openbao.ErrNotFound) {
return false, err
}
return true, c.PutKV(ctx, path, data)
}
func keysOf(data map[string]any) []string {
out := make([]string, 0, len(data))
for k := range data {
out = append(out, k)
}
return out
}