0
0
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
}
}
}
}