SPB Git

Repository Public

state.go 10.4 KB 366 lines go

1// Package state owns the agent's state directory: identity, key material,2// the persistent report sequence and small status files. The directory is3// 0700 and every file 0600; the private key is generated here and never4// leaves the node.5package state67import (8	"crypto/ecdsa"9	"crypto/ed25519"10	"crypto/tls"11	"crypto/x509"12	"encoding/base64"13	"encoding/json"14	"encoding/pem"15	"errors"16	"fmt"17	"os"18	"path/filepath"19	"strconv"20	"strings"21	"sync"22	"syscall"23	"time"24)2526const (27	fileIdentity = "identity.json"28	fileKey      = "agent.key"29	fileCert     = "agent.crt"30	fileCA       = "ca.crt"31	fileCmdKeys  = "command-keys.json"32	fileSeq      = "seq"33	fileStatus   = "status.json"34	fileLock     = "agent.lock"35	// FreezeFile is the local kill switch: while it exists, every command is refused.36	FreezeFile = "FREEZE"37	PolicyFile = "policy.json"38)3940// Dir is an opened state directory.41type Dir struct {42	Path string4344	seqMu       sync.Mutex45	seqNext     int6446	seqReserved int6447	lock        *os.File48}4950// DefaultPath is ~/.mcc-agent, or $MCC_AGENT_STATE_DIR.51func DefaultPath() string {52	if v := os.Getenv("MCC_AGENT_STATE_DIR"); v != "" {53		return v54	}55	home, err := os.UserHomeDir()56	if err != nil || home == "" {57		return ".mcc-agent"58	}59	return filepath.Join(home, ".mcc-agent")60}6162// Open creates the directory if needed and enforces its mode.63func Open(path string) (*Dir, error) {64	abs, err := filepath.Abs(path)65	if err != nil {66		return nil, err67	}68	if err := os.MkdirAll(abs, 0o700); err != nil {69		return nil, fmt.Errorf("state dir: %w", err)70	}71	if err := os.Chmod(abs, 0o700); err != nil {72		return nil, fmt.Errorf("state dir mode: %w", err)73	}74	return &Dir{Path: abs}, nil75}7677// File returns the path of a file inside the directory.78func (d *Dir) File(name string) string { return filepath.Join(d.Path, name) }7980// Lock takes the single-instance lock. A second `run` on the same state81// directory would corrupt the sequence and the spool; it fails here instead.82func (d *Dir) Lock() error {83	f, err := os.OpenFile(d.File(fileLock), os.O_RDWR|os.O_CREATE, 0o600)84	if err != nil {85		return err86	}87	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {88		f.Close()89		return errors.New("another mcc-agent is already running on this state directory")90	}91	f.Truncate(0)92	f.WriteString(strconv.Itoa(os.Getpid()) + "\n")93	d.lock = f94	return nil95}9697// Unlock releases the single-instance lock.98func (d *Dir) Unlock() {99	if d.lock != nil {100		syscall.Flock(int(d.lock.Fd()), syscall.LOCK_UN)101		d.lock.Close()102		d.lock = nil103	}104}105106// WriteAtomic writes a file through a fsynced temporary file and a rename.107func WriteAtomic(path string, data []byte, mode os.FileMode, sync bool) error {108	f, err := os.CreateTemp(filepath.Dir(path), ".tmp-*")109	if err != nil {110		return err111	}112	tmp := f.Name()113	defer os.Remove(tmp)114	if err := f.Chmod(mode); err != nil {115		f.Close()116		return err117	}118	if _, err := f.Write(data); err != nil {119		f.Close()120		return err121	}122	if sync {123		if err := f.Sync(); err != nil {124			f.Close()125			return err126		}127	}128	if err := f.Close(); err != nil {129		return err130	}131	if err := os.Rename(tmp, path); err != nil {132		return err133	}134	if sync {135		SyncDir(filepath.Dir(path))136	}137	return nil138}139140// SyncDir fsyncs a directory so a rename or creation survives a power loss.141func SyncDir(dir string) {142	if d, err := os.Open(dir); err == nil {143		d.Sync()144		d.Close()145	}146}147148// Identity is what enrollment established.149type Identity struct {150	AgentID    string    `json:"agent_id"`151	NodeID     string    `json:"node_id"`152	ServerName string    `json:"server_name"`153	Endpoints  []string  `json:"endpoints"`154	IntervalS  int       `json:"interval_s"`155	EnrolledAt time.Time `json:"enrolled_at"`156}157158// ErrNotEnrolled means the state directory holds no identity.159var ErrNotEnrolled = errors.New("agent is not enrolled (run: mcc-agent enroll …)")160161func (d *Dir) LoadIdentity() (*Identity, error) {162	b, err := os.ReadFile(d.File(fileIdentity))163	if errors.Is(err, os.ErrNotExist) {164		return nil, ErrNotEnrolled165	}166	if err != nil {167		return nil, err168	}169	var id Identity170	if err := json.Unmarshal(b, &id); err != nil {171		return nil, fmt.Errorf("identity.json: %w", err)172	}173	if id.AgentID == "" || len(id.Endpoints) == 0 {174		return nil, errors.New("identity.json is incomplete")175	}176	return &id, nil177}178179func (d *Dir) SaveIdentity(id *Identity) error {180	b, _ := json.MarshalIndent(id, "", "  ")181	return WriteAtomic(d.File(fileIdentity), append(b, '\n'), 0o600, true)182}183184// SaveCredentials stores key, certificate and CA after enrollment or renewal.185// Key and certificate are replaced together in one atomic rename; a crash186// before it leaves the previous pair, which the server still accepts during187// the renewal overlap.188func (d *Dir) SaveCredentials(key *ecdsa.PrivateKey, certPEM, caPEM []byte) error {189	if _, err := tlsPair(key, certPEM); err != nil {190		return fmt.Errorf("certificate does not match the key: %w", err)191	}192	if caPEM != nil {193		if err := WriteAtomic(d.File(fileCA), caPEM, 0o600, true); err != nil {194			return err195		}196	}197	der, err := x509.MarshalECPrivateKey(key)198	if err != nil {199		return err200	}201	// Key and certificate travel as one file so they can never be mismatched on disk.202	bundle := append(pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: der}), certPEM...)203	if err := WriteAtomic(d.File(fileKey), bundle, 0o600, true); err != nil {204		return err205	}206	return WriteAtomic(d.File(fileCert), certPEM, 0o600, true)207}208209func tlsPair(key *ecdsa.PrivateKey, certPEM []byte) (*tls.Certificate, error) {210	der, err := x509.MarshalECPrivateKey(key)211	if err != nil {212		return nil, err213	}214	c, err := tls.X509KeyPair(certPEM, pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: der}))215	if err != nil {216		return nil, err217	}218	c.Leaf, err = x509.ParseCertificate(c.Certificate[0])219	return &c, err220}221222// LoadCredentials returns the client certificate (with Leaf) and the CA pool.223func (d *Dir) LoadCredentials() (*tls.Certificate, *x509.CertPool, error) {224	bundle, err := os.ReadFile(d.File(fileKey))225	if errors.Is(err, os.ErrNotExist) {226		return nil, nil, ErrNotEnrolled227	}228	if err != nil {229		return nil, nil, err230	}231	c, err := tls.X509KeyPair(bundle, bundle)232	if err != nil {233		return nil, nil, fmt.Errorf("agent credentials: %w", err)234	}235	if c.Leaf, err = x509.ParseCertificate(c.Certificate[0]); err != nil {236		return nil, nil, err237	}238	caPEM, err := os.ReadFile(d.File(fileCA))239	if err != nil {240		return nil, nil, err241	}242	pool := x509.NewCertPool()243	if !pool.AppendCertsFromPEM(caPEM) {244		return nil, nil, errors.New("ca.crt holds no certificate")245	}246	return &c, pool, nil247}248249// SaveCommandKeys stores the orchestrator's public command keys.250func (d *Dir) SaveCommandKeys(keys map[string]string) error {251	if _, err := DecodeCommandKeys(keys); err != nil {252		return err253	}254	b, _ := json.MarshalIndent(keys, "", "  ")255	return WriteAtomic(d.File(fileCmdKeys), append(b, '\n'), 0o600, true)256}257258// DecodeCommandKeys parses key id -> base64 Ed25519 public key.259func DecodeCommandKeys(keys map[string]string) (map[string]ed25519.PublicKey, error) {260	out := make(map[string]ed25519.PublicKey, len(keys))261	for id, b64 := range keys {262		raw, err := base64.StdEncoding.DecodeString(b64)263		if err != nil || len(raw) != ed25519.PublicKeySize {264			return nil, fmt.Errorf("command key %q is not an Ed25519 public key", id)265		}266		out[id] = ed25519.PublicKey(raw)267	}268	return out, nil269}270271func (d *Dir) LoadCommandKeys() (map[string]ed25519.PublicKey, error) {272	b, err := os.ReadFile(d.File(fileCmdKeys))273	if errors.Is(err, os.ErrNotExist) {274		return map[string]ed25519.PublicKey{}, nil275	}276	if err != nil {277		return nil, err278	}279	var keys map[string]string280	if err := json.Unmarshal(b, &keys); err != nil {281		return nil, fmt.Errorf("command-keys.json: %w", err)282	}283	return DecodeCommandKeys(keys)284}285286// Frozen reports whether the local kill switch is engaged.287func (d *Dir) Frozen() bool {288	_, err := os.Lstat(d.File(FreezeFile))289	return err == nil290}291292// ─────────────────────────── sequence ───────────────────────────293294// seqBlock is how many sequence numbers are reserved per fsync. After a295// crash the sequence resumes at the reserved mark: numbers may be skipped296// (the server tolerates gaps) but are never reused.297const seqBlock = 64298299// NextSeq returns the next report sequence number, durably unique.300func (d *Dir) NextSeq() (int64, error) {301	d.seqMu.Lock()302	defer d.seqMu.Unlock()303	if d.seqReserved == 0 {304		b, err := os.ReadFile(d.File(fileSeq))305		switch {306		case err == nil:307			n, perr := strconv.ParseInt(strings.TrimSpace(string(b)), 10, 64)308			if perr != nil || n < 0 {309				return 0, fmt.Errorf("seq file is corrupt: %q", strings.TrimSpace(string(b)))310			}311			d.seqNext = n312		case errors.Is(err, os.ErrNotExist):313			d.seqNext = 0314		default:315			return 0, err316		}317		d.seqReserved = d.seqNext318	}319	if d.seqNext >= d.seqReserved {320		res := d.seqNext + seqBlock321		if err := WriteAtomic(d.File(fileSeq), []byte(strconv.FormatInt(res, 10)+"\n"), 0o600, true); err != nil {322			return 0, err323		}324		d.seqReserved = res325	}326	d.seqNext++327	return d.seqNext, nil328}329330// ─────────────────────────── status ───────────────────────────331332// Status is written by `run` and read by `status`.333type Status struct {334	PID            int       `json:"pid"`335	Version        string    `json:"version"`336	StartedAt      time.Time `json:"started_at"`337	UpdatedAt      time.Time `json:"updated_at"`338	Connection     string    `json:"connection"` // online | offline | revoked339	Endpoint       string    `json:"endpoint"`340	LastReportOK   time.Time `json:"last_report_ok"`341	LastSeq        int64     `json:"last_seq"`342	LastError      string    `json:"last_error,omitempty"`343	SpoolReports   int       `json:"spool_reports"`344	SpoolBytes     int64     `json:"spool_bytes"`345	Dropped        int64     `json:"dropped_reports"`346	SelfCPUPercent *float64  `json:"self_cpu_percent,omitempty"`347	SelfRSSBytes   *int64    `json:"self_rss_bytes,omitempty"`348	Frozen         bool      `json:"frozen"`349	PolicyError    string    `json:"policy_error,omitempty"`350	Capabilities   []string  `json:"capabilities"`351}352353func (d *Dir) SaveStatus(s *Status) error {354	b, _ := json.MarshalIndent(s, "", "  ")355	return WriteAtomic(d.File(fileStatus), append(b, '\n'), 0o600, false)356}357358func (d *Dir) LoadStatus() (*Status, error) {359	b, err := os.ReadFile(d.File(fileStatus))360	if err != nil {361		return nil, err362	}363	var s Status364	return &s, json.Unmarshal(b, &s)365}366
Files main
Menu

Theme