package guestagent import ( "context" "encoding/json" "errors" "fmt" "io/fs" "os" "path/filepath" "regexp" "strconv" "strings" "github.com/fsnotify/fsnotify" ) const ( maxSecretsCiphertext = 65536 maxSecretEntries = 256 defaultSecretMode = 0o600 ) type secretEntry struct { Path string `json:"path"` Value string `json:"value"` Mode string `json:"mode,omitempty"` } type secretsRequestedRecord struct { Type string `json:"$type"` CreatedAt string `json:"createdAt"` } type secretsAppliedRecord struct { Type string `json:"$type"` Via string `json:"via"` Count int `json:"count"` CreatedAt string `json:"createdAt"` } func (a *Agent) readyPath() string { return filepath.Join(a.cfg.StateDir, SecretsReadyFile) } func (a *Agent) runSecrets(ctx context.Context) { key := publicKeyRecord{Type: PublicKeyNSID, Kind: publicKeyKindAgeX25519, Tag: secretsTag, Key: a.identity.Recipient().String(), CreatedAt: createdAt()} a.wg.Go(func() { _ = a.poster.Post(ctx, key.Type, secretsTag, key) }) a.log.Info("the sealed secrets path is enabled (comms mode Firehose)") if _, _, ok := a.readReady(); !ok { a.postRequest(ctx) } } func exists(path string) bool { _, err := os.Stat(path) return err == nil } func (a *Agent) readReady() (string, int, bool) { raw, err := os.ReadFile(a.readyPath()) if err != nil { return "", 0, false } fields := strings.Fields(string(raw)) if len(fields) == 0 { return "", 0, false } count := 0 if len(fields) > 1 { count, _ = strconv.Atoi(fields[1]) } return fields[0], max(count, 0), true } func (a *Agent) postRequest(ctx context.Context) { a.mu.Lock() if a.requested { a.mu.Unlock() return } a.requested = true a.mu.Unlock() record := secretsRequestedRecord{Type: SecretsRequestedNSID, CreatedAt: createdAt()} a.log.Info("the guest asks the requester for its sealed secrets bundle") a.wg.Go(func() { if err := a.poster.Post(ctx, record.Type, "", record); err != nil { a.mu.Lock() a.requested = false a.mu.Unlock() } }) } func (a *Agent) postApplied(ctx context.Context, via string, count int) { a.mu.Lock() if a.applied[via] { a.mu.Unlock() return } a.applied[via] = true a.mu.Unlock() record := secretsAppliedRecord{Type: SecretsAppliedNSID, Via: via, Count: count, CreatedAt: createdAt()} a.wg.Go(func() { _ = a.poster.Post(ctx, record.Type, "", record) }) } func (a *Agent) sealedSecrets(ctx context.Context, seq int64, ciphertext string) { if a.cfg.Secrets == nil { a.log.Debug("a secrets event for a guest without the sealed fallback", "seq", seq) return } if ciphertext == "" || len(ciphertext) > maxSecretsCiphertext { a.log.Debug("a secrets ciphertext is empty or too large", "seq", seq, "bytes", len(ciphertext)) return } plaintext, err := open(a.identity, ciphertext) if err != nil { a.log.Debug("a secrets event does not open with this guest's identity", "seq", seq) return } var entries []secretEntry if err := json.Unmarshal(plaintext, &entries); err != nil { a.log.Warn("a secrets bundle opened but is not a JSON array of {path, value, mode}", "seq", seq, "bytes", len(plaintext)) return } clear(plaintext) if err := writeSecrets(entries); err != nil { a.log.Error("writing the sealed secrets bundle failed", "seq", seq, "err", err.Error()) return } if err := writeReady(a.readyPath(), secretsViaSealed, len(entries)); err != nil { a.log.Error("marking the secrets ready failed", "err", err.Error()) return } a.log.Info("the sealed secrets bundle is written", "seq", seq, "files", len(entries)) a.mu.Lock() a.applied[secretsViaSealed] = false a.mu.Unlock() a.postApplied(ctx, secretsViaSealed, len(entries)) } var secretModeRE = regexp.MustCompile(`^0?[0-7]{1,3}$`) func secretMode(raw string) (os.FileMode, error) { if raw == "" { return defaultSecretMode, nil } if !secretModeRE.MatchString(raw) { return 0, errors.New("the mode is not an octal string of at most 0777") } value, err := strconv.ParseUint(raw, 8, 32) if err != nil { return 0, errors.New("the mode is not an octal string of at most 0777") } return os.FileMode(value), nil } func checkSecretPath(path string) error { if path == "" || path == "/" || !strings.HasPrefix(path, "/") || strings.ContainsFunc(path, secretPathControl) || filepath.Clean(path) != path { return errors.New("the path is not a clean absolute path") } return nil } func secretPathControl(r rune) bool { return r < 0x20 || r == 0x7f } func writeSecrets(entries []secretEntry) error { if len(entries) > maxSecretEntries { return fmt.Errorf("the bundle names %d files, more than %d", len(entries), maxSecretEntries) } modes := make([]os.FileMode, len(entries)) for i, entry := range entries { if err := checkSecretPath(entry.Path); err != nil { return fmt.Errorf("the secrets bundle is refused and nothing is written: entry %d: %w", i, err) } mode, err := secretMode(entry.Mode) if err != nil { return fmt.Errorf("the secrets bundle is refused and nothing is written: entry %d: %w", i, err) } modes[i] = mode } for i, entry := range entries { if err := writeSecretFile(entry.Path, []byte(entry.Value), modes[i]); err != nil { return fmt.Errorf("entry %d: %w", i, err) } } return nil } func makeMissingDirs(dir string) error { if _, err := os.Lstat(dir); err == nil { return nil } else if !errors.Is(err, fs.ErrNotExist) { return err } if err := makeMissingDirs(filepath.Dir(dir)); err != nil { return err } if err := os.Mkdir(dir, 0o700); err != nil { if errors.Is(err, fs.ErrExist) { return nil } return err } if err := os.Chmod(dir, 0o700); err != nil { return err } return os.Chown(dir, 0, 0) } func writeSecretFile(path string, value []byte, mode os.FileMode) error { dir := filepath.Dir(path) if err := makeMissingDirs(dir); err != nil { return err } tmp, err := os.CreateTemp(dir, ".secret.*") if err != nil { return err } name := tmp.Name() done := false defer func() { if !done { _ = os.Remove(name) } }() if err := tmp.Chmod(mode); err != nil { tmp.Close() return err } if err := tmp.Chown(0, 0); err != nil { tmp.Close() return err } if _, err := tmp.Write(value); err != nil { tmp.Close() return err } if err := tmp.Sync(); err != nil { tmp.Close() return err } if err := tmp.Close(); err != nil { return err } if err := os.Rename(name, path); err != nil { return err } done = true return nil } func writeReady(path, via string, count int) error { if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { return err } part := path + ".part" if err := os.WriteFile(part, []byte(via+" "+strconv.Itoa(count)+"\n"), 0o600); err != nil { return err } return os.Rename(part, path) } func WaitSecrets(ctx context.Context, stateDir string) error { if err := os.MkdirAll(stateDir, 0o700); err != nil { return err } watcher, err := fsnotify.NewWatcher() if err != nil { return err } defer watcher.Close() if err := watcher.Add(stateDir); err != nil { return err } ready := filepath.Join(stateDir, SecretsReadyFile) if exists(ready) { return nil } for { select { case <-ctx.Done(): return ctx.Err() case err, open := <-watcher.Errors: if !open { return errors.New("guestagent: the secrets watcher closed") } return err case ev, open := <-watcher.Events: if !open { return errors.New("guestagent: the secrets watcher closed") } if ev.Name == ready && exists(ready) { return nil } } } }