214 lines
7.6 KiB
Go
214 lines
7.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json/jsontext"
|
|
json "encoding/json/v2"
|
|
"errors"
|
|
"fmt"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"golang.org/x/crypto/ssh"
|
|
|
|
"github.com/samcharles93/archipelago/sdk/connector"
|
|
connectorv1 "github.com/samcharles93/archipelago/sdk/connector/v1"
|
|
)
|
|
|
|
// Target is one host the connector may reach, from its hosts setting.
|
|
type Target struct {
|
|
Name string `json:"name"`
|
|
Address string `json:"address"`
|
|
// HostKey is the host's public key in authorized_keys form, as
|
|
// ssh-keyscan prints it. A host presenting any other key is refused.
|
|
HostKey string `json:"host_key"`
|
|
// Helpers runs the lookups that walk directories through the root-owned
|
|
// helpers in target/, so they see what the account alone can't read.
|
|
Helpers bool `json:"helpers"`
|
|
// Paths are the roots lookups may look under. Lookups run no guards and
|
|
// may read as root, so a path outside them is refused: an instruction
|
|
// injected into an event can't steer the agent into the rest of the host.
|
|
Paths []string `json:"paths"`
|
|
// Environment is what the host is for (production, staging), declared on
|
|
// every action's target so policy can tell them apart.
|
|
Environment string `json:"environment"`
|
|
// Disposable are the host's temp and cache directories, inside Paths.
|
|
// Deleting from one is recoverable by regeneration; deleting from anywhere
|
|
// else under Paths is irreversible.
|
|
Disposable []string `json:"disposable"`
|
|
// Timers are the systemd timers the connector may enable and disable.
|
|
Timers []string `json:"timers"`
|
|
// ConfigFiles are the files whose keys the connector may set, each owned
|
|
// by the connector's account.
|
|
ConfigFiles []string `json:"config_files"`
|
|
|
|
key ssh.PublicKey
|
|
}
|
|
|
|
type host struct {
|
|
targets map[string]Target
|
|
username string
|
|
signer ssh.Signer
|
|
// runner executes a command on a host; tests replace it.
|
|
runner func(ctx context.Context, target Target, command string) execResult
|
|
}
|
|
|
|
func newHost(cfg connector.Config) (*host, error) {
|
|
var targets []Target
|
|
if err := json.Unmarshal([]byte(cfg.Settings["hosts"]), &targets); err != nil {
|
|
return nil, fmt.Errorf("hosts setting: %w", err)
|
|
}
|
|
h := &host{targets: map[string]Target{}, username: cfg.Secrets["ssh.username"]}
|
|
for _, t := range targets {
|
|
key, _, _, _, err := ssh.ParseAuthorizedKey([]byte(t.HostKey))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("host %q: host_key: %w", t.Name, err)
|
|
}
|
|
t.key = key
|
|
for i, root := range t.Paths {
|
|
if !path.IsAbs(root) {
|
|
return nil, fmt.Errorf("host %q: path root %q must be absolute", t.Name, root)
|
|
}
|
|
t.Paths[i] = path.Clean(root)
|
|
}
|
|
if err := t.checkActionSettings(); err != nil {
|
|
return nil, fmt.Errorf("host %q: %w", t.Name, err)
|
|
}
|
|
h.targets[t.Name] = t
|
|
}
|
|
pem, pass := cfg.Secrets["ssh.private_key"], cfg.Secrets["ssh.private_key_passphrase"]
|
|
if h.username == "" || pem == "" {
|
|
return nil, errNoCredential
|
|
}
|
|
h.runner = h.execute
|
|
var err error
|
|
if pass != "" {
|
|
h.signer, err = ssh.ParsePrivateKeyWithPassphrase([]byte(pem), []byte(pass))
|
|
} else {
|
|
h.signer, err = ssh.ParsePrivateKey([]byte(pem))
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ssh private key: %w", err)
|
|
}
|
|
return h, nil
|
|
}
|
|
|
|
func (h *host) Describe() connector.Description {
|
|
return connector.Description{Actions: h.actionTypes(), Lookups: []*connectorv1.LookupType{
|
|
{
|
|
Name: "filesystem_usage",
|
|
Description: "Size, used and available bytes and inode use of the filesystem holding a path on a host.",
|
|
InputSchema: []byte(`{"type":"object","required":["host","path"],"additionalProperties":false,"properties":{"host":{"type":"string"},"path":{"type":"string","description":"An absolute path."}}}`),
|
|
},
|
|
{
|
|
Name: "directory_sizes",
|
|
Description: "The largest entries directly under a directory on a host, by total size, staying on its filesystem.",
|
|
InputSchema: []byte(`{"type":"object","required":["host","path"],"additionalProperties":false,"properties":{"host":{"type":"string"},"path":{"type":"string","description":"An absolute path."},"limit":{"type":"integer","minimum":1,"maximum":50}}}`),
|
|
},
|
|
{
|
|
Name: "old_files",
|
|
Description: "The largest files under a directory on a host not modified for at least a number of hours, staying on its filesystem.",
|
|
InputSchema: []byte(`{"type":"object","required":["host","path"],"additionalProperties":false,"properties":{"host":{"type":"string"},"path":{"type":"string","description":"An absolute path."},"older_than_hours":{"type":"integer","minimum":0},"limit":{"type":"integer","minimum":1,"maximum":50}}}`),
|
|
},
|
|
}}
|
|
}
|
|
|
|
type lookupInput struct {
|
|
Host string `json:"host"`
|
|
Path string `json:"path"`
|
|
Limit int `json:"limit"`
|
|
OlderThanHours *int `json:"older_than_hours"`
|
|
}
|
|
|
|
func (h *host) Lookup(ctx context.Context, name string, raw jsontext.Value) (jsontext.Value, bool, error) {
|
|
var in lookupInput
|
|
if err := json.Unmarshal(raw, &in); err != nil {
|
|
return nil, false, fmt.Errorf("input: %w", err)
|
|
}
|
|
target, ok := h.targets[in.Host]
|
|
if !ok {
|
|
return nil, false, fmt.Errorf("host %q isn't configured", in.Host)
|
|
}
|
|
p, err := checkPath(in.Path, target.Paths)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
limit := in.Limit
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
command, parse, err := lookupCommand(name, p, limit, in.OlderThanHours, target.Helpers)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
out, err := h.run(ctx, target, command)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
result, err := parse(out)
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("%s on %s: %w", name, in.Host, err)
|
|
}
|
|
encoded, err := json.Marshal(result)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
return encoded, true, nil
|
|
}
|
|
|
|
// lookupCommand builds the fixed command for a lookup. Every argument from
|
|
// the input is shell-quoted, because ssh hands the command to the remote
|
|
// shell.
|
|
func lookupCommand(name, p string, limit int, olderThan *int, helpers bool) (string, func([]byte) (any, error), error) {
|
|
q := quote(p)
|
|
n := strconv.Itoa(limit)
|
|
switch name {
|
|
case "filesystem_usage":
|
|
return "LC_ALL=C df -P -B1 -- " + q + " && LC_ALL=C df -P -i -- " + q, parseDF, nil
|
|
case "directory_sizes":
|
|
if helpers {
|
|
return helperDir + "directory-sizes " + q + " " + n, parseDU, nil
|
|
}
|
|
return "LC_ALL=C du -x -B1 --max-depth=1 -- " + q + " 2>/dev/null | sort -rn | head -n " + n, parseDU, nil
|
|
case "old_files":
|
|
hours := 24
|
|
if olderThan != nil {
|
|
hours = *olderThan
|
|
}
|
|
minutes := strconv.Itoa(hours * 60)
|
|
if helpers {
|
|
return helperDir + "old-files " + q + " " + minutes + " " + n, parseFind, nil
|
|
}
|
|
return "LC_ALL=C find " + q + " -xdev -type f -mmin +" + minutes +
|
|
" -printf '%s\\t%T@\\t%u\\t%p\\n' 2>/dev/null | sort -rn | head -n " + n, parseFind, nil
|
|
}
|
|
return "", nil, fmt.Errorf("no lookup named %q", name)
|
|
}
|
|
|
|
// helperDir is where target/install.sh puts the helpers, run through sudo.
|
|
const helperDir = "sudo -n /usr/local/libexec/archie/"
|
|
|
|
// checkPath accepts an absolute path with no control characters that, once
|
|
// cleaned, is one of roots or lies under one.
|
|
func checkPath(p string, roots []string) (string, error) {
|
|
if !path.IsAbs(p) {
|
|
return "", fmt.Errorf("path %q must be absolute", p)
|
|
}
|
|
if strings.ContainsFunc(p, func(r rune) bool { return r < 0x20 || r == 0x7f }) {
|
|
return "", errors.New("path contains control characters")
|
|
}
|
|
clean := path.Clean(p)
|
|
for _, root := range roots {
|
|
if clean == root || strings.HasPrefix(clean, strings.TrimSuffix(root, "/")+"/") {
|
|
return clean, nil
|
|
}
|
|
}
|
|
return "", fmt.Errorf("path %q is outside this host's lookup paths %v", clean, roots)
|
|
}
|
|
|
|
// quote makes s one single-quoted shell word.
|
|
func quote(s string) string {
|
|
return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
|
|
}
|