0
0
package tlsreload
import (
"context"
"crypto/tls"
"crypto/x509"
"encoding/pem"
"errors"
"fmt"
"log/slog"
"net"
"os"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/lease"
)
const LoadWait = 10 * time.Second
type Pool struct {
log *slog.Logger
mu sync.Mutex
source *lease.Source[*x509.CertPool]
path string
stamp stamp
pool *x509.CertPool
loaded chan struct{}
}
func NewPool(fetch lease.Fetch[*x509.CertPool], log *slog.Logger) *Pool {
p := &Pool{log: logOrDiscard(log)}
if fetch != nil {
p.source = lease.New(fetch)
}
return p
}
func PEMPool(data []byte, log *slog.Logger) (*Pool, error) {
pool, err := parsePool(data)
if err != nil {
return nil, err
}
return &Pool{log: logOrDiscard(log), pool: pool}, nil
}
func FilePool(path string, log *slog.Logger) (*Pool, error) {
path = strings.TrimSpace(path)
if path == "" {
return nil, errors.New("tlsreload: no CA bundle file")
}
st := statFile(path)
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("tlsreload: reading the CA bundle %s: %w", path, err)
}
pool, err := parsePool(data)
if err != nil {
return nil, fmt.Errorf("tlsreload: the CA bundle %s: %w", path, err)
}
return &Pool{log: logOrDiscard(log), path: path, stamp: st, pool: pool}, nil
}
func PoolFromBundle(value string, log *slog.Logger) (*Pool, error) {
value = strings.TrimSpace(value)
if value == "" {
return nil, errors.New("tlsreload: the CA bundle is empty")
}
if strings.Contains(value, "-----BEGIN") {
return PEMPool([]byte(value), log)
}
return FilePool(strings.TrimPrefix(value, "file:"), log)
}
func (p *Pool) Set(data []byte) error {
pool, err := parsePool(data)
if err != nil {
return err
}
p.mu.Lock()
p.pool = pool
p.source = nil
p.path = ""
p.stamp = stamp{}
loaded := p.loadedLocked()
select {
case <-loaded:
default:
close(loaded)
}
p.mu.Unlock()
return nil
}
func (p *Pool) loadedLocked() chan struct{} {
if p.loaded == nil {
p.loaded = make(chan struct{})
}
return p.loaded
}
func (p *Pool) Current(ctx context.Context) (*x509.CertPool, error) {
p.mu.Lock()
source := p.source
if source == nil && p.path != "" {
p.refreshLocked()
}
pool := p.pool
var loaded chan struct{}
if source == nil && pool == nil {
loaded = p.loadedLocked()
}
p.mu.Unlock()
if source != nil {
fetched, err := source.Get(ctx)
if err != nil {
return nil, fmt.Errorf("tlsreload: fetching the CA pool: %w", err)
}
pool = fetched
}
if loaded != nil {
pool = p.awaitLoaded(ctx, loaded)
}
if pool == nil {
return nil, errors.New("tlsreload: no CA pool is loaded")
}
return pool, nil
}
func (p *Pool) awaitLoaded(ctx context.Context, loaded <-chan struct{}) *x509.CertPool {
timer := time.NewTimer(LoadWait)
defer timer.Stop()
select {
case <-loaded:
case <-ctx.Done():
case <-timer.C:
}
p.mu.Lock()
defer p.mu.Unlock()
return p.pool
}
func (p *Pool) ServerConfig(base *tls.Config, auth tls.ClientAuthType) *tls.Config {
if base == nil {
base = &tls.Config{}
}
cfg := base.Clone()
cfg.ClientAuth = auth
inner := base.GetConfigForClient
plain := base.Clone()
plain.GetConfigForClient = nil
cfg.GetConfigForClient = func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
next := plain
if inner != nil {
got, err := inner(hello)
if err != nil {
return nil, err
}
if got != nil {
next = got
}
}
pool, err := p.Current(hello.Context())
if err != nil {
return nil, err
}
out := next.Clone()
out.GetConfigForClient = nil
out.ClientCAs = pool
out.ClientAuth = auth
return out, nil
}
return cfg
}
func (p *Pool) DialTLSContext(base *tls.Config) func(ctx context.Context, network, addr string) (net.Conn, error) {
if base == nil {
base = &tls.Config{}
}
base = base.Clone()
return func(ctx context.Context, network, addr string) (net.Conn, error) {
roots, err := p.Current(ctx)
if err != nil {
return nil, err
}
cfg := base.Clone()
cfg.RootCAs = roots
if cfg.ServerName == "" {
host, _, err := net.SplitHostPort(addr)
if err != nil {
host = addr
}
cfg.ServerName = host
}
if len(cfg.NextProtos) == 0 {
cfg.NextProtos = []string{"http/1.1"}
}
dialer := &tls.Dialer{Config: cfg}
return dialer.DialContext(ctx, network, addr)
}
}
func (p *Pool) refreshLocked() {
st := statFile(p.path)
if sameStamps([]stamp{st}, []stamp{p.stamp}) {
return
}
data, err := os.ReadFile(p.path)
var pool *x509.CertPool
if err == nil {
pool, err = parsePool(data)
}
if err != nil {
p.log.Warn("keeping the last CA pool", "path", p.path, "err", err)
} else {
p.pool = pool
p.log.Info("reloaded the CA pool", "path", p.path)
}
p.stamp = st
}
func statFile(path string) stamp {
st, err := os.Stat(path)
if err != nil {
return stamp{}
}
return stamp{mod: st.ModTime(), size: st.Size(), ok: true}
}
func parsePool(data []byte) (*x509.CertPool, error) {
pool := x509.NewCertPool()
if pool.AppendCertsFromPEM(data) {
return pool, nil
}
block, _ := pem.Decode(data)
if block == nil || block.Type != "CERTIFICATE" {
return nil, errors.New("tlsreload: the CA bundle holds no certificate")
}
if _, err := x509.ParseCertificate(block.Bytes); err != nil {
return nil, fmt.Errorf("tlsreload: parsing the CA certificate: %w", err)
}
return nil, errors.New("tlsreload: the CA bundle holds no certificate")
}
func logOrDiscard(log *slog.Logger) *slog.Logger {
if log == nil {
return slog.New(slog.DiscardHandler)
}
return log
}