0
0
package compose
import (
"context"
"crypto/rand"
"crypto/tls"
"encoding/hex"
"errors"
"fmt"
"math/big"
"net/http"
"os"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bus"
contractvault "github.com/johnandersen777/socialweb-computer-kcp/internal/contract/vault"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/openbaoctl"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vault/openbao"
)
const (
RepoKeyField = "repoKeyHex"
passwordBytes = 24
)
func (c *Composer) ApplyVault(ctx context.Context, r Root, name string) error {
obj := &v1alpha1.Vault{ObjectMeta: metav1.ObjectMeta{Name: name},
Spec: v1alpha1.VaultSpec{BackendRef: commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: KindOpenBaoServer, Name: name}}}
return c.ApplyTyped(ctx, r, r.Workspace, VaultGVR, v1alpha1.GroupVersion.String(), KindVault, obj)
}
func RootVaultLink(r Root, vaultName string, prefixes ...string) Link {
return VaultLink(r.Ref(), vaultName, true, prefixes...)
}
func (c *Composer) KV(ctx context.Context, r Root, vaultName string, scope ...string) (contractvault.KV, error) {
return bus.Resolve[contractvault.KV](ctx, c.cfg.Bus, r.Ref(), VaultRefIn(vaultName, r.Workspace),
bus.Capability{Name: contractvault.CapabilityWrite, Scope: cleanPrefixes(scope)})
}
func readKV(ctx context.Context, kv contractvault.KV, mount, path string) (map[string]any, error) {
data, err := kv.Read(ctx, mount, path, 0)
var re *openbao.ResponseError
if err != nil && !(errors.As(err, &re) && re.Status == http.StatusNotFound) {
return nil, err
}
if data == nil {
data = map[string]any{}
}
return data, nil
}
func ReadKV(ctx context.Context, kv contractvault.KV, mount, path string) (map[string]any, error) {
return readKV(ctx, kv, mount, path)
}
func NewPassword() (string, error) {
buf := make([]byte, passwordBytes)
if _, err := rand.Read(buf); err != nil {
return "", err
}
return hex.EncodeToString(buf), nil
}
var secp256k1N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)
func NewRepoKeyHex() (string, error) {
for {
buf := make([]byte, 32)
if _, err := rand.Read(buf); err != nil {
return "", err
}
k := new(big.Int).SetBytes(buf)
if k.Sign() > 0 && k.Cmp(secp256k1N) < 0 {
return hex.EncodeToString(buf), nil
}
}
}
func (c *Composer) EnsureRepoKey(ctx context.Context, r Root, vaultName, mount, keysPath string) error {
kv, err := c.KV(ctx, r, vaultName, mount+"/identity/*")
if err != nil {
return err
}
if err := c.ApplyVaultCredential(ctx, r, vaultName, mount, keysPath); err != nil {
return err
}
data, err := readKV(ctx, kv, mount, keysPath)
if err != nil {
return err
}
if k, _ := data[RepoKeyField].(string); k != "" {
return nil
}
key, err := NewRepoKeyHex()
if err != nil {
return err
}
data[RepoKeyField] = key
if err := kv.Write(ctx, mount, keysPath, data); err != nil {
return err
}
c.log.Info("the application's repo key is in its own vault", "vault", vaultName, "path", keysPath)
return nil
}
func (c *Composer) Password(ctx context.Context, r Root, vaultName, mount, path string) (string, error) {
kv, err := c.KV(ctx, r, vaultName, mount+"/identity/*")
if err != nil {
return "", err
}
data, err := readKV(ctx, kv, mount, path)
if err != nil {
return "", err
}
if password, _ := data["password"].(string); password != "" {
return password, nil
}
password, err := NewPassword()
if err != nil {
return "", err
}
data["password"] = password
if err := kv.Write(ctx, mount, path, data); err != nil {
return "", err
}
return password, nil
}
func (c *Composer) VaultRefs(ctx context.Context, ws, server, clientName string) (v1alpha1.OpenBaoServerStatus, v1alpha1.OpenBaoServerClientRefs, error) {
o, err := Get[v1alpha1.OpenBaoServer](ctx, c, ws, OpenBaoServerGVR, server)
if err != nil {
return v1alpha1.OpenBaoServerStatus{}, v1alpha1.OpenBaoServerClientRefs{}, err
}
st := o.Status
if st.Address == "" || st.Refs == nil {
return st, v1alpha1.OpenBaoServerClientRefs{}, fmt.Errorf("the OpenBaoServer %s reports no address yet (phase %s)", server, st.Phase)
}
for _, x := range st.Clients {
if x.Name == clientName && x.ClientCert != "" {
return st, x, nil
}
}
return st, v1alpha1.OpenBaoServerClientRefs{}, fmt.Errorf("the OpenBaoServer %s reports no client %s yet", server, clientName)
}
func (c *Composer) KVMount(ctx context.Context, ws, server, clientName, fallback string) string {
_, refs, err := c.VaultRefs(ctx, ws, server, clientName)
if err != nil || strings.TrimSpace(refs.KVMount) == "" {
return fallback
}
return strings.Trim(refs.KVMount, "/")
}
func ServerClient(ctx context.Context, r kube.Resource, server, clientName string) (*openbao.Client, v1alpha1.OpenBaoServerStatus, v1alpha1.OpenBaoServerClientRefs, error) {
o, err := kube.Get[v1alpha1.OpenBaoServer](ctx, r, server)
if err != nil {
return nil, v1alpha1.OpenBaoServerStatus{}, v1alpha1.OpenBaoServerClientRefs{}, err
}
st := o.Status
if st.Address == "" || st.Refs == nil {
return nil, st, v1alpha1.OpenBaoServerClientRefs{}, fmt.Errorf("the OpenBaoServer %s reports no address yet (phase %s)", server, st.Phase)
}
var cl v1alpha1.OpenBaoServerClientRefs
for _, x := range st.Clients {
if x.Name == clientName {
cl = x
}
}
if cl.ClientCert == "" {
return nil, st, cl, fmt.Errorf("the OpenBaoServer %s reports no client %s yet", server, clientName)
}
caPEM, err := os.ReadFile(openbaoctl.FileRef(st.Refs.CA))
if err != nil {
return nil, st, cl, err
}
pool, err := openbao.CertPoolFromPEM(caPEM)
if err != nil {
return nil, st, cl, err
}
cert, err := tls.LoadX509KeyPair(openbaoctl.FileRef(cl.ClientCert), openbaoctl.FileRef(cl.ClientKey))
if err != nil {
return nil, st, cl, err
}
client := openbao.New(st.Address, "", openbao.WithCACertPool(pool), openbao.WithClientCertificate(cert))
logged, err := client.LoginCert(ctx, cl.CertAuthMount, cl.CertAuthRole)
if err != nil {
return nil, st, cl, err
}
return logged, st, cl, nil
}
func (c *Composer) ServerClient(ctx context.Context, ws, server, clientName string) (*openbao.Client, v1alpha1.OpenBaoServerClientRefs, error) {
ri, err := c.Client(ws, OpenBaoServerGVR)
if err != nil {
return nil, v1alpha1.OpenBaoServerClientRefs{}, err
}
client, _, refs, err := ServerClient(ctx, ri, server, clientName)
return client, refs, err
}
func (c *Composer) DeleteVaults(ctx context.Context, r Root) (int, error) {
vaults, err := c.DeleteOwned(ctx, r.Workspace, VaultGVR, r.Owner())
if err != nil {
return vaults, err
}
servers, err := c.DeleteOwned(ctx, r.Workspace, OpenBaoServerGVR, r.Owner())
return vaults + servers, err
}