Repository Public
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