0
0
package tenantcredentialmain
import (
"context"
"crypto/x509"
"encoding/pem"
"errors"
"fmt"
"os"
"path/filepath"
"slices"
"strings"
"time"
"k8s.io/client-go/rest"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clusterkcp"
"github.com/johnandersen777/socialweb-computer-kcp/internal/foldmain"
)
const caCertName = "ca.crt"
const clientCertName = "tls.crt"
const clientKeyName = "tls.key"
func Main(ctx context.Context, inv foldmain.Invocation) int {
if err := run(ctx, inv); err != nil {
fmt.Fprintln(inv.Stderr, "socialweb-tenantcredential:", err)
return 1
}
return 0
}
func run(ctx context.Context, inv foldmain.Invocation) error {
cfg, err := load(inv.Env)
if err != nil {
return err
}
if err := os.MkdirAll(cfg.OutDir, 0o700); err != nil {
return fmt.Errorf("creating the out dir %s: %w", cfg.OutDir, err)
}
if err := refuseExisting(cfg.OutDir); err != nil {
return err
}
restCfg, err := clusterkcp.MintTenantCredentialForClusterAs(
ctx, cfg.StateDir, cfg.Cluster, cfg.Server, cfg.CommonName, cfg.Organizations, cfg.ValidFor)
if err != nil {
return err
}
leaf, err := identityOf(restCfg)
if err != nil {
return err
}
if err := checkIdentity(leaf, cfg.CommonName, cfg.Organizations); err != nil {
return err
}
paths, err := writeCredential(cfg.OutDir, restCfg)
if err != nil {
return err
}
fmt.Fprintf(inv.Stdout, "socialweb-tenantcredential: cluster=%s commonName=%s organizations=%s validUntil=%s "+
"ca=%s cert=%s key=%s\n", cfg.Cluster, cfg.CommonName, strings.Join(cfg.Organizations, ","),
leaf.NotAfter.UTC().Format(time.RFC3339), paths[0], paths[1], paths[2])
return nil
}
func refuseExisting(dir string) error {
var found []string
for _, name := range []string{caCertName, clientCertName, clientKeyName} {
path := filepath.Join(dir, name)
if _, err := os.Stat(path); err == nil {
found = append(found, path)
}
}
if len(found) > 0 {
return fmt.Errorf(
"these files already exist and this tool will not overwrite a credential: %s. "+
"Overwriting would replace the credential some runner or controller is already "+
"authenticating with, and that silent replacement is the failure invariant 20 "+
"exists to prevent. Move the existing files aside, or name a different out dir",
strings.Join(found, ", "))
}
return nil
}
func identityOf(cfg *rest.Config) (*x509.Certificate, error) {
if len(cfg.TLSClientConfig.CertData) == 0 {
return nil, errors.New("the minting path returned a credential with no client " +
"certificate, so there is no identity to compare against what was asked for and " +
"nothing to write to tls.crt")
}
for block, rest := pem.Decode(cfg.TLSClientConfig.CertData); block != nil; block, rest = pem.Decode(rest) {
if block.Type != "CERTIFICATE" {
continue
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, fmt.Errorf("the minted client certificate does not parse: %w", err)
}
return cert, nil
}
return nil, errors.New("the minted client certificate holds no CERTIFICATE PEM block")
}
func checkIdentity(leaf *x509.Certificate, commonName string, organizations []string) error {
if leaf.Subject.CommonName != commonName {
return fmt.Errorf(
"the minted credential authenticates as %q and %s asked for %q. The certificate is the "+
"artifact: an operator whose RBAC binds %q would be handed a credential for %q, and "+
"every rule keyed on it would miss. This tool refuses rather than write a credential "+
"whose identity is not the one that was asked for",
leaf.Subject.CommonName, envCommonName, commonName, commonName, leaf.Subject.CommonName)
}
if !slices.Equal(leaf.Subject.Organization, organizations) {
return fmt.Errorf(
"the minted credential carries the organizations %v and %s asked for %v. The apiserver "+
"reads the groups off the Organizations, so a mismatch is a credential whose groups "+
"the operator's RBAC does not bind: this tool refuses rather than write it",
leaf.Subject.Organization, envOrganizations, organizations)
}
return nil
}
func writeCredential(dir string, cfg *rest.Config) ([3]string, error) {
files := [3]struct {
name string
data []byte
why string
}{
{caCertName, cfg.CAData,
"the cluster's server CA, which is what verifies the apiserver's own certificate"},
{clientCertName, cfg.TLSClientConfig.CertData, "the minted client certificate"},
{clientKeyName, cfg.TLSClientConfig.KeyData, "the minted client key"},
}
var missing []string
for _, f := range files {
if len(f.data) == 0 {
missing = append(missing, fmt.Sprintf("%s (%s)", f.name, f.why))
}
}
if len(missing) > 0 {
return [3]string{}, fmt.Errorf(
"the minted credential is missing %s. The three files are a set and a partial one is "+
"refused rather than written: ca.crt without tls.crt has nothing to present, and "+
"tls.key without tls.crt is a private key that authenticates nothing, so a reader "+
"of the directory would find a credential that looks complete and is not",
strings.Join(missing, " and "))
}
var paths [3]string
written := make([]string, 0, len(files))
for i, f := range files {
path, err := writeOne(dir, f.name, f.data)
if err != nil {
for _, done := range written {
_ = os.Remove(done)
}
return [3]string{}, err
}
paths[i] = path
written = append(written, path)
}
return paths, nil
}
func writeOne(dir, name string, data []byte) (string, error) {
tmp, err := os.CreateTemp(dir, name+".tmp-*")
if err != nil {
return "", fmt.Errorf("creating a temporary file for %s in %s: %w", name, dir, err)
}
tmpName := tmp.Name()
if _, err := tmp.Write(data); err != nil {
_ = tmp.Close()
_ = os.Remove(tmpName)
return "", fmt.Errorf("writing %s: %w", tmpName, err)
}
if err := tmp.Chmod(0o600); err != nil {
_ = tmp.Close()
_ = os.Remove(tmpName)
return "", fmt.Errorf("setting %s to mode 0600: %w", tmpName, err)
}
if err := tmp.Close(); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("closing %s: %w", tmpName, err)
}
final := filepath.Join(dir, name)
if err := os.Rename(tmpName, final); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("renaming %s into place as %s: %w", tmpName, final, err)
}
return final, nil
}