0
0
package vaultlayout
import (
"errors"
"fmt"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/identitybundle"
)
type VaultName string
const (
Root VaultName = "root"
Cluster VaultName = "cluster"
)
type MountKind string
const (
MountKV MountKind = "kv-v2"
MountPKI MountKind = "pki"
)
const (
MountKVRoot = "secret/"
MountPKIRoot = "pki/"
MountKVCluster = "secret/"
)
const (
PathKCPAdmin = "secret/data/socialweb/kcp/admin"
PathKCPAdminTokenStore = "secret/data/socialweb/kcp/admin-token-store"
PathKCPClientCA = "secret/data/socialweb/kcp/client-ca"
PathContainerTLS = "secret/data/socialweb/container/tls"
PathClusterIdentity = "secret/data/k3s/identity"
PathClusterInstanceToken = "secret/data/k3s/instance-token"
PathClusterPostgres = "secret/data/k3s/postgres"
PathClusterSSH = "secret/data/k3s/ssh"
PathDoorClaimsPrefix = "secret/data/socialweb-door/claims/"
)
const DoorClaimSecretsIngressKey = "secrets-ingress"
func DoorClaimSecretsIngressPath(claim string) string {
return PathDoorClaimsPrefix + claim + "/" + DoorClaimSecretsIngressKey
}
const (
RootServerName = "root-vault"
RootClient = "gateway"
PolicyRootWriter = "root-writer"
)
const (
PolicyKCPRuntime = "kcp-runtime"
PolicyKCPAdminTokenStore = "kcp-admin-token-store"
PolicyKCPCA = "kcp-ca"
PolicyContainerTLS = "container-tls"
PolicyKCPClientIssue = "kcp-client-issue"
PolicyIdentityBundle = "identity-bundle"
PolicyInstanceToken = "instance-token"
PolicyPostgres = "postgres"
PolicySSH = "ssh"
)
const (
RoleGateway = "gateway"
RoleClusterProvider = "clusterprovider"
RoleContainerTLS = "container-tls"
RoleClusterIdentity = "cluster-identity"
RoleClusterData = "cluster-data"
RoleClusterNode = "cluster-node"
RoleKCPClient = "kcp-client"
)
type SecretClassName string
const (
ClassKCPAdminKubeconfig SecretClassName = "kcp-admin-kubeconfig"
ClassKCPAdminTokenStore SecretClassName = "kcp-admin-token-store"
ClassKCPClientCA SecretClassName = "kcp-client-ca"
ClassContainerTLS SecretClassName = "container-tls-certificate"
ClassIdentityBundle SecretClassName = "identity-bundle"
ClassInstanceToken SecretClassName = "instance-token"
ClassPostgresCredential SecretClassName = "postgres-credential"
ClassPerClusterSSHKey SecretClassName = "per-cluster-ssh-key"
)
type Mount struct {
Vault VaultName
Path string
Kind MountKind
MaxLeaseTTL time.Duration
}
type Policy struct {
Vault VaultName
Name string
HCL string
}
type AppRole struct {
Vault VaultName
Name string
Policies []string
TokenTTL time.Duration
TokenMaxTTL time.Duration
SecretIDTTL time.Duration
}
type PKIRole struct {
Vault VaultName
Mount string
Name string
AllowedDomains []string
AllowSubdomains bool
AllowBareDomains bool
AllowIPSANs bool
EnforceHostnames bool
RequireCN bool
ClientAuth bool
ServerAuth bool
KeyUsage []string
KeyType string
KeyBits int
TTL time.Duration
MaxTTL time.Duration
}
type SecretClass struct {
Name SecretClassName
Vault VaultName
}
type Secret struct {
Vault VaultName
Path string
Class SecretClassName
Consumer string
Keys []string
}
type Layout struct {
Mounts []Mount
Policies []Policy
AppRoles []AppRole
PKIRoles []PKIRole
Secrets []Secret
SecretClasses []SecretClass
}
func readPolicy(paths ...string) string {
var b strings.Builder
for _, p := range paths {
fmt.Fprintf(&b, "path \"%s\" {\n capabilities = [\"read\"]\n}\n", p)
}
return b.String()
}
func issuePolicy(paths ...string) string {
var b strings.Builder
for _, p := range paths {
fmt.Fprintf(&b, "path \"%s\" {\n capabilities = [\"create\", \"update\"]\n}\n", p)
}
return b.String()
}
func Default() Layout {
return Layout{
Mounts: []Mount{
{Vault: Root, Path: MountKVRoot, Kind: MountKV},
{Vault: Root, Path: MountPKIRoot, Kind: MountPKI, MaxLeaseTTL: 8760 * time.Hour},
{Vault: Cluster, Path: MountKVCluster, Kind: MountKV},
},
Policies: []Policy{
{Vault: Root, Name: PolicyKCPRuntime, HCL: readPolicy(PathKCPAdmin)},
{Vault: Root, Name: PolicyKCPAdminTokenStore, HCL: readPolicy(PathKCPAdminTokenStore)},
{Vault: Root, Name: PolicyKCPCA, HCL: readPolicy(PathKCPClientCA)},
{Vault: Root, Name: PolicyContainerTLS, HCL: readPolicy(PathContainerTLS)},
{Vault: Root, Name: PolicyKCPClientIssue, HCL: issuePolicy(MountPKIRoot + "issue/" + RoleKCPClient)},
{Vault: Cluster, Name: PolicyIdentityBundle, HCL: readPolicy(PathClusterIdentity)},
{Vault: Cluster, Name: PolicyInstanceToken, HCL: readPolicy(PathClusterInstanceToken)},
{Vault: Cluster, Name: PolicyPostgres, HCL: readPolicy(PathClusterPostgres)},
{Vault: Cluster, Name: PolicySSH, HCL: readPolicy(PathClusterSSH)},
},
AppRoles: []AppRole{
{
Vault: Root,
Name: RoleGateway,
Policies: []string{PolicyKCPRuntime, PolicyKCPClientIssue},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
{
Vault: Root,
Name: RoleClusterProvider,
Policies: []string{PolicyKCPAdminTokenStore, PolicyKCPCA},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
{
Vault: Root,
Name: RoleContainerTLS,
Policies: []string{PolicyContainerTLS},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
{
Vault: Cluster,
Name: RoleClusterIdentity,
Policies: []string{PolicyIdentityBundle, PolicyInstanceToken},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
{
Vault: Cluster,
Name: RoleClusterData,
Policies: []string{PolicyPostgres},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
{
Vault: Cluster,
Name: RoleClusterNode,
Policies: []string{PolicySSH},
TokenTTL: time.Hour,
TokenMaxTTL: 4 * time.Hour,
SecretIDTTL: 30 * time.Minute,
},
},
PKIRoles: []PKIRole{
{
Vault: Root,
Mount: MountPKIRoot,
Name: RoleKCPClient,
AllowedDomains: []string{"socialweb.local"},
AllowSubdomains: true,
AllowBareDomains: false,
AllowIPSANs: false,
EnforceHostnames: true,
RequireCN: true,
ClientAuth: true,
ServerAuth: false,
KeyUsage: []string{"DigitalSignature", "KeyEncipherment"},
KeyType: "ecdsa",
KeyBits: 256,
TTL: 168 * time.Hour,
MaxTTL: 720 * time.Hour,
},
},
Secrets: []Secret{
{
Vault: Root,
Path: PathKCPAdmin,
Class: ClassKCPAdminKubeconfig,
Consumer: RoleGateway,
Keys: []string{"kubeconfig"},
},
{
Vault: Root,
Path: PathKCPAdminTokenStore,
Class: ClassKCPAdminTokenStore,
Consumer: RoleClusterProvider,
Keys: []string{"token-hash"},
},
{
Vault: Root,
Path: PathKCPClientCA,
Class: ClassKCPClientCA,
Consumer: RoleClusterProvider,
Keys: []string{"ca.crt"},
},
{
Vault: Root,
Path: PathContainerTLS,
Class: ClassContainerTLS,
Consumer: RoleContainerTLS,
Keys: []string{"tls.crt", "tls.key"},
},
{
Vault: Cluster,
Path: PathClusterIdentity,
Class: ClassIdentityBundle,
Consumer: RoleClusterIdentity,
Keys: identitybundle.Paths,
},
{
Vault: Cluster,
Path: PathClusterInstanceToken,
Class: ClassInstanceToken,
Consumer: RoleClusterIdentity,
Keys: []string{"token"},
},
{
Vault: Cluster,
Path: PathClusterPostgres,
Class: ClassPostgresCredential,
Consumer: RoleClusterData,
Keys: []string{"username", "password", "database"},
},
{
Vault: Cluster,
Path: PathClusterSSH,
Class: ClassPerClusterSSHKey,
Consumer: RoleClusterNode,
Keys: []string{"id_ed25519", "id_ed25519.pub"},
},
},
SecretClasses: []SecretClass{
{Name: ClassKCPAdminKubeconfig, Vault: Root},
{Name: ClassKCPAdminTokenStore, Vault: Root},
{Name: ClassKCPClientCA, Vault: Root},
{Name: ClassContainerTLS, Vault: Root},
{Name: ClassIdentityBundle, Vault: Cluster},
{Name: ClassInstanceToken, Vault: Cluster},
{Name: ClassPostgresCredential, Vault: Cluster},
{Name: ClassPerClusterSSHKey, Vault: Cluster},
},
}
}
func policyPaths(hcl string) []string {
var out []string
for line := range strings.SplitSeq(hcl, "\n") {
line = strings.TrimSpace(line)
if !strings.HasPrefix(line, "path \"") {
continue
}
rest := strings.TrimPrefix(line, "path \"")
if before, _, ok := strings.Cut(rest, "\""); ok {
out = append(out, before)
}
}
return out
}
func providedBy(mounts map[string]Mount, path string) bool {
for _, m := range mounts {
if strings.HasPrefix(path, m.Path) {
return true
}
}
return false
}
func Validate(l Layout) error {
var errs []error
mounts := map[VaultName]map[string]Mount{}
for _, m := range l.Mounts {
if mounts[m.Vault] == nil {
mounts[m.Vault] = map[string]Mount{}
}
mounts[m.Vault][m.Path] = m
}
policies := map[VaultName]map[string]Policy{}
for _, p := range l.Policies {
if policies[p.Vault] == nil {
policies[p.Vault] = map[string]Policy{}
}
if _, dup := policies[p.Vault][p.Name]; dup {
errs = append(errs, fmt.Errorf("policy %s/%s is declared twice", p.Vault, p.Name))
}
policies[p.Vault][p.Name] = p
for _, path := range policyPaths(p.HCL) {
if !providedBy(mounts[p.Vault], path) {
errs = append(errs, fmt.Errorf(
"policy %s/%s references path %q, which no mount in the %s vault provides",
p.Vault, p.Name, path, p.Vault))
}
}
}
roles := map[VaultName]map[string]AppRole{}
for _, r := range l.AppRoles {
if roles[r.Vault] == nil {
roles[r.Vault] = map[string]AppRole{}
}
if _, dup := roles[r.Vault][r.Name]; dup {
errs = append(errs, fmt.Errorf("role %s/%s is declared twice", r.Vault, r.Name))
}
roles[r.Vault][r.Name] = r
if len(r.Policies) == 0 {
errs = append(errs, fmt.Errorf("role %s/%s names no policy", r.Vault, r.Name))
}
for _, name := range r.Policies {
if _, ok := policies[r.Vault][name]; !ok {
errs = append(errs, fmt.Errorf(
"role %s/%s references policy %q, which does not exist in the %s vault",
r.Vault, r.Name, name, r.Vault))
}
}
}
for _, r := range l.PKIRoles {
m, ok := mounts[r.Vault][r.Mount]
if !ok {
errs = append(errs, fmt.Errorf(
"PKI role %s/%s names mount %q, which the %s vault does not have",
r.Vault, r.Name, r.Mount, r.Vault))
continue
}
if m.Kind != MountPKI {
errs = append(errs, fmt.Errorf(
"PKI role %s/%s names mount %q, which is %s and not pki",
r.Vault, r.Name, r.Mount, m.Kind))
}
if r.MaxTTL > m.MaxLeaseTTL {
errs = append(errs, fmt.Errorf(
"PKI role %s/%s has max TTL %s, above its mount %q max lease TTL %s",
r.Vault, r.Name, r.MaxTTL, r.Mount, m.MaxLeaseTTL))
}
if !r.ClientAuth && !r.ServerAuth {
errs = append(errs, fmt.Errorf(
"PKI role %s/%s grants neither client nor server auth", r.Vault, r.Name))
}
}
declared := map[SecretClassName]SecretClass{}
for _, c := range l.SecretClasses {
if _, dup := declared[c.Name]; dup {
errs = append(errs, fmt.Errorf("secret class %q is declared twice", c.Name))
}
declared[c.Name] = c
}
counts := map[SecretClassName]int{}
for _, s := range l.Secrets {
c, ok := declared[s.Class]
if !ok {
errs = append(errs, fmt.Errorf(
"secret %s/%s has class %q, which is not declared", s.Vault, s.Path, s.Class))
continue
}
counts[s.Class]++
if c.Vault != s.Vault {
errs = append(errs, fmt.Errorf(
"secret %s/%s has class %q, whose home is the %s vault, not the %s vault",
s.Vault, s.Path, s.Class, c.Vault, s.Vault))
}
if _, ok := roles[s.Vault][s.Consumer]; !ok {
errs = append(errs, fmt.Errorf(
"secret %s/%s names consumer %q, which is not a role in the %s vault",
s.Vault, s.Path, s.Consumer, s.Vault))
}
if !providedBy(mounts[s.Vault], s.Path) {
errs = append(errs, fmt.Errorf(
"secret %s/%s is not under any mount in the %s vault", s.Vault, s.Path, s.Vault))
}
if s.Class == ClassIdentityBundle && len(s.Keys) != len(identitybundle.Paths) {
errs = append(errs, fmt.Errorf(
"secret %s/%s is the identity bundle and holds %d keys, want %d",
s.Vault, s.Path, len(s.Keys), len(identitybundle.Paths)))
}
}
for _, c := range l.SecretClasses {
switch {
case counts[c.Name] == 0:
errs = append(errs, fmt.Errorf(
"secret class %q is assigned to no secret, so it has no vault", c.Name))
case counts[c.Name] > 1:
errs = append(errs, fmt.Errorf(
"secret class %q is assigned to %d secrets, so it has more than one vault",
c.Name, counts[c.Name]))
}
}
return errors.Join(errs...)
}