0
0
package guestseed
import (
"cmp"
"fmt"
"net"
"net/netip"
"net/url"
"path"
"regexp"
"sort"
"strconv"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/cloudinit"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/guestnet"
)
const (
AcceptPathVM = "/root/secrets/publicdomainrelay.com/market/accept.json"
SecretsPrefix = "/root/secrets/digitalocean.com/serviceaccount"
OnNetworkBaseURLPath = SecretsPrefix + "/base_url"
GuestCurlrcPath = "/root/.curlrc"
NetworkServicesPath = "/etc/socialweb-guest-agent/network-services"
GuestTLSProxyUnit = "swc-guest-tls"
GuestLoginScript = cloudinit.GuestLoginScriptPath
GuestLoginUnit = cloudinit.GuestLoginUnit
GuestLoginTokenPath = cloudinit.GuestLoginTokenPath
GuestLoginNamespace = cloudinit.GuestLoginNamespace
GuestLoginDefaultMount = cloudinit.GuestLoginDefaultMount
GuestLoginRoute = "/v1"
OnNetworkScript = cloudinit.OnNetworkScriptPath
OnNetworkUnit = "guest-onnetwork.service"
IrohServiceUnit = "iroh.service"
IrohListenerScript = "/usr/local/bin/iroh-listener.sh"
IrohTicketPath = "/run/guest-iroh-ticket"
GuestFQDNPath = "/run/guest-fqdn"
IrohTargetPort = 22
PoweroffModule = cloudinit.PoweroffEndsVMModule
PoweroffPath = cloudinit.PoweroffEndsVMPath
)
var (
guestLoginRoleRE = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
guestLoginMountRE = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`)
guestBindSecretRE = regexp.MustCompile(`^[0-9a-f]{64}$`)
guestLocalhostURL = regexp.MustCompile(`(?i)https://([a-z0-9.-]+\.localhost)`)
guestAnyLocalhostURL = regexp.MustCompile(`(?i)https?://([a-z0-9.-]+\.localhost)`)
guestHostURL = regexp.MustCompile(`(?i)(https?)://(?:[a-z0-9.-]+\.localhost|` + regexp.QuoteMeta(guestnet.HostAddress) + `)(?::([0-9]{1,5}))?`)
)
type GuestLoginOptions = cloudinit.GuestLoginOptions
type ProvisionOptions struct {
UserData string
Login *GuestLoginOptions
AcceptPath string
FallbackURL string
BearerAudience string
Reporter bool
BaseURL bool
HostAddress string
TLSPort int
HostURL string
Downloads map[string]string
WebRTC *WebRTCOptions
Memory bool
}
func GuestLoginModule(opts GuestLoginOptions) (cloudinit.UserDataModule, error) {
if err := validateGuestLogin(opts); err != nil {
return nil, err
}
return cloudinit.GuestLoginModule(opts), nil
}
func IrohTransportModule(userData string) (cloudinit.UserDataModule, error) {
if strings.Contains(userData, IrohServiceUnit) || strings.Contains(userData, IrohListenerScript) {
return nil, nil
}
modules, err := cloudinit.GetUserDataModules([]any{cloudinit.GuestTransportModule})
if err != nil {
return nil, err
}
if len(modules) != 1 {
return nil, fmt.Errorf("guestseed: the %s user-data module is not registered", cloudinit.GuestTransportModule)
}
inner := modules[0]
return func(ctx cloudinit.Context) (cloudinit.UserDataPatch, error) {
patch, err := inner(ctx)
if err != nil {
return cloudinit.UserDataPatch{}, err
}
if ctx.SSHAuthorizedKey != "" {
return patch, nil
}
files := patch.WriteFiles[:0]
for _, file := range patch.WriteFiles {
if file.Path == "/root/.ssh/authorized_keys" {
continue
}
files = append(files, file)
}
patch.WriteFiles = files
return patch, nil
}, nil
}
func WithIrohTransport(userData string, authorizedKeys, hostAliases []string) (string, error) {
if !strings.HasPrefix(strings.TrimLeft(userData, " \t\r\n"), "#cloud-config") {
return userData, nil
}
module, err := IrohTransportModule(userData)
if err != nil || module == nil {
return userData, err
}
keys := make([]string, 0, len(authorizedKeys))
for _, key := range authorizedKeys {
key = strings.TrimSpace(key)
if key != "" {
keys = append(keys, key)
}
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{
Base: userData,
Modules: []any{module},
Ctx: cloudinit.Context{
SSHAuthorizedKey: strings.Join(keys, "\n"),
TargetPort: IrohTargetPort,
HostAliases: hostAliases,
DumbpipeVersion: cloudinit.DumbpipeVersionDefault,
},
})
}
func AcceptBundle(acceptPath string, bundle map[string]any) (cloudinit.UserDataModule, error) {
acceptPath = cmp.Or(acceptPath, AcceptPathVM)
if err := checkAbsolute(acceptPath); err != nil {
return nil, err
}
return cloudinit.AcceptBundleModule(acceptPath, bundle), nil
}
func OnNetworkReporterModule(userData, fallbackURL, acceptPath, bearerAudience, hostURL string) (cloudinit.UserDataModule, bool, error) {
if strings.Contains(userData, OnNetworkUnit) {
return nil, false, nil
}
acceptPath = cmp.Or(acceptPath, AcceptPathVM)
if err := checkAbsolute(acceptPath); err != nil {
return nil, false, err
}
targets := guestnet.RelayTargets(userData, fallbackURL)
if len(targets) == 0 || targets[0].URL == "" {
return nil, false, fmt.Errorf("guestseed: the guest reports on-network to no URL; the fallback %q is not one", fallbackURL)
}
if hostURL = strings.TrimRight(strings.TrimSpace(hostURL), "/"); hostURL != "" {
targets = append([]guestnet.RelayTarget{{URL: hostURL + guestnet.EventsPath}}, targets...)
}
for _, target := range targets {
if err := checkURLLike(target.URL, "on-network URL"); err != nil {
return nil, false, err
}
}
if bearerAudience != "" && !safeInDoubleQuotes(bearerAudience) {
return nil, false, fmt.Errorf("guestseed: bearer audience %q carries a character a shell would read", bearerAudience)
}
var attempts strings.Builder
auth := ""
if bearerAudience != "" {
auth = ` -H "Authorization: Bearer ${TOKEN}"`
}
for i, target := range targets {
code := fmt.Sprintf("CODE%d", i+1)
resolve := ""
if target.Resolve != "" {
resolve = `--resolve ` + strconv.Quote(target.Resolve) + ` `
}
fmt.Fprintf(&attempts, " %s=\"$(curl -sS -m 20 -o \"${OUT}\" -w '%%{http_code}' %s\\\n", code, resolve)
fmt.Fprintf(&attempts, " -X POST %s -H 'Content-Type: application/json'%s -d \"${PAYLOAD}\" \\\n", strconv.Quote(target.URL), auth)
attempts.WriteString(" 2>>\"${ERR}\" || echo 000)\"\n")
fmt.Fprintf(&attempts, " echo \"guest-onnetwork: http ${%s} %s\"\n", code, target.URL)
fmt.Fprintf(&attempts, " if [ \"${%s}\" = \"200\" ]; then echo \"guest-onnetwork: reported ${FQDN}\"; exit 0; fi\n", code)
}
script := `#!/usr/bin/env bash
set -uo pipefail
ACCEPT_JSON="` + acceptPath + `"
if [ ! -f "${ACCEPT_JSON}" ]; then echo "guest-onnetwork: no ${ACCEPT_JSON}"; exit 0; fi
TAG="${1:-}"
OUT="/tmp/guest-onnetwork${TAG:+-${TAG}}.out"
ERR="/tmp/guest-onnetwork${TAG:+-${TAG}}.err"
FQDN=""
if [ -n "${TAG}" ]; then
FQDN="${2:-}"
if [ -z "${FQDN}" ]; then echo "guest-onnetwork: no address for the tag ${TAG}"; exit 1; fi
else
for _ in $(seq 1 45); do
FQDN="$(cat /run/guest-fqdn 2>/dev/null || true)"
[ -n "${FQDN}" ] && break
systemctl is-failed --quiet iroh.service && { echo "guest-onnetwork: iroh.service failed"; break; }
sleep 2
done
if [ -z "${FQDN}" ]; then
echo "guest-onnetwork: no /run/guest-fqdn"
echo "guest-onnetwork: iroh is $(systemctl is-active iroh.service 2>&1), restarts=$(systemctl show -p NRestarts --value iroh.service 2>&1)"
journalctl -u iroh.service --no-pager -n 40 2>&1 | tail -40
exit 0
fi
fi
ACCEPT_URI="$(jq -r '.accept.uri // empty' "${ACCEPT_JSON}")"
ACCEPT_CID="$(jq -r '.accept.cid // empty' "${ACCEPT_JSON}")"
if [ -z "${ACCEPT_URI}" ] || [ -z "${ACCEPT_CID}" ]; then echo "guest-onnetwork: accept.json has no accept ref"; exit 0; fi
PAYLOAD="$(jq -nc --arg au "${ACCEPT_URI}" --arg ac "${ACCEPT_CID}" --arg addr "${FQDN}" --arg tag "${TAG}" \
--arg nsid "` + market.ComputeEventsVMOnNetworkNSID + `" --arg at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
'{acceptUri: $au, acceptCid: $ac, record: ({"$type": $nsid, address: $addr, createdAt: $at} + (if $tag == "" then {} else {tag: $tag} end))}')"
echo "guest-onnetwork: reporting ${TAG:+${TAG} }${FQDN}"
for _ in 1 2 3 4 5; do
` + bearerLines(bearerAudience) + attempts.String() + ` sleep 6
done
echo "guest-onnetwork: gave up; last response: $(cat "${OUT}" 2>/dev/null)"
if [ -n "${TAG}" ]; then exit 1; fi
`
after := "iroh.service"
wants := "iroh.service"
if bearerAudience != "" {
after += " " + GuestLoginUnit
wants += " " + GuestLoginUnit
}
unit := strings.Join([]string{
"[Unit]",
"Description=Report the guest iroh ticket to the market",
"After=network-online.target " + after,
"Wants=network-online.target " + wants,
"",
"[Service]",
"Type=oneshot",
"RemainAfterExit=yes",
"ExecStart=" + OnNetworkScript,
"StandardOutput=journal+console",
"StandardError=journal+console",
"",
"[Install]",
"WantedBy=multi-user.target",
"",
}, "\n")
module := func(cloudinit.Context) (cloudinit.UserDataPatch, error) {
return cloudinit.UserDataPatch{
WriteFiles: []cloudinit.WriteFileEntry{
{Path: OnNetworkScript, Owner: "root:root", Permissions: "0700", Content: script},
{Path: "/etc/systemd/system/" + OnNetworkUnit, Owner: "root:root", Permissions: "0644", Content: unit},
},
RuncmdPrepend: []any{
"systemctl daemon-reload",
"systemctl enable --no-block " + OnNetworkUnit,
"systemctl start --no-block " + OnNetworkUnit,
},
}, nil
}
return module, true, nil
}
func bearerLines(audience string) string {
if audience == "" {
return ""
}
return ` TOKEN="$(` + GuestLoginScript + ` token "` + audience + `")" || TOKEN=""
if [ -z "${TOKEN}" ]; then echo "guest-onnetwork: no token from the bidder's OpenBao yet"; sleep 6; continue; fi
`
}
func OnNetworkBaseURLModule(userData, fallbackURL string) (cloudinit.UserDataModule, bool, error) {
if strings.Contains(userData, OnNetworkBaseURLPath) {
return nil, false, nil
}
target := guestnet.OnNetworkURLFromBundle(userData, fallbackURL)
if target == "" {
return nil, false, fmt.Errorf("guestseed: the guest names no on-network URL; the fallback %q is not one", fallbackURL)
}
if err := checkURLLike(target, "on-network URL"); err != nil {
return nil, false, err
}
u, err := url.Parse(target)
if err != nil || u.Host == "" {
return nil, false, fmt.Errorf("guestseed: on-network URL %q is not a URL", target)
}
origin := u.Scheme + "://" + u.Host
parent := path.Dir(OnNetworkBaseURLPath)
module := func(cloudinit.Context) (cloudinit.UserDataPatch, error) {
return cloudinit.UserDataPatch{
WriteFiles: []cloudinit.WriteFileEntry{{Path: OnNetworkBaseURLPath, Owner: "root:root", Permissions: "0600", Content: origin + "\n"}},
RuncmdPrepend: []any{[]any{"sh", "-c", "install -d -m 0700 -o root -g root " + shellQuote(parent)}},
}, nil
}
return module, true, nil
}
func PointAtHostModules(userData, gateway string, tlsPort int) (string, []cloudinit.UserDataModule, error) {
if tlsPort < 0 || tlsPort > 65535 {
return "", nil, fmt.Errorf("guestseed: guest TLS port %d is not a port", tlsPort)
}
rewritten := userData
if tlsPort > 0 {
rewritten = addGuestTLSPort(userData, tlsPort)
}
hosts := localhostHosts(rewritten)
if len(hosts) == 0 && tlsPort == 0 {
return rewritten, nil, nil
}
addr, err := netip.ParseAddr(strings.TrimSpace(gateway))
if err != nil || !addr.Is4() {
return "", nil, fmt.Errorf("guestseed: host address %q is not an IPv4 address", gateway)
}
var lines []any
for _, host := range hosts {
lines = append(lines, []any{"sh", "-c", "echo " + addr.String() + " " + host + " >> /etc/hosts"})
}
for i, j := 0, len(lines)-1; i < j; i, j = i+1, j-1 {
lines[i], lines[j] = lines[j], lines[i]
}
var files []cloudinit.WriteFileEntry
if tlsPort > 0 {
// a portless https://<name>.relay.localhost (a network PDS's or PLC's ingress URL in a DID document) is port 443 on
// loopback (systemd-resolved answers *.localhost with it): a socket proxy there passes it, SNI and all, to the
// guest TLS front on the host (plan 0049)
unit := "/etc/systemd/system/" + GuestTLSProxyUnit
files = []cloudinit.WriteFileEntry{{Path: GuestCurlrcPath, Owner: "root:root", Permissions: "0644",
Content: "resolve = *:" + strconv.Itoa(tlsPort) + ":" + addr.String() + "\n"},
{Path: unit + ".socket", Owner: "root:root", Permissions: "0644",
Content: "[Socket]\nListenStream=127.0.0.1:443\nListenStream=[::1]:443\nBindIPv6Only=ipv6-only\n\n[Install]\nWantedBy=sockets.target\n"},
{Path: unit + ".service", Owner: "root:root", Permissions: "0644",
Content: "[Service]\nExecStart=/usr/lib/systemd/systemd-socket-proxyd " + net.JoinHostPort(addr.String(), strconv.Itoa(tlsPort)) + "\n"}}
lines = append(lines, []any{"systemctl", "enable", "--now", GuestTLSProxyUnit + ".socket"})
}
module := func(cloudinit.Context) (cloudinit.UserDataPatch, error) {
return cloudinit.UserDataPatch{WriteFiles: files, RuncmdPrepend: lines}, nil
}
return rewritten, []cloudinit.UserDataModule{module}, nil
}
func WithNetwork(userData string, urls []string, caPEM string) (string, error) {
caPEM = strings.TrimSpace(caPEM)
if len(urls) == 0 && caPEM == "" {
return userData, nil
}
module := func(cloudinit.Context) (cloudinit.UserDataPatch, error) {
var patch cloudinit.UserDataPatch
if len(urls) > 0 {
patch.WriteFiles = []cloudinit.WriteFileEntry{{Path: NetworkServicesPath, Owner: "root:root", Permissions: "0644", Content: strings.Join(urls, "\n") + "\n"}}
}
for _, raw := range urls {
u, err := url.Parse(raw)
if err != nil || u.Port() == "" {
return cloudinit.UserDataPatch{}, fmt.Errorf("guestseed: network service %q names no port", raw)
}
unit := "/etc/systemd/system/swc-network-" + u.Port()
patch.WriteFiles = append(patch.WriteFiles,
cloudinit.WriteFileEntry{Path: unit + ".socket", Owner: "root:root", Permissions: "0644",
Content: "[Socket]\nListenStream=127.0.0.1:" + u.Port() + "\n\n[Install]\nWantedBy=sockets.target\n"},
cloudinit.WriteFileEntry{Path: unit + ".service", Owner: "root:root", Permissions: "0644",
Content: "[Service]\nExecStart=/usr/lib/systemd/systemd-socket-proxyd " + guestnet.HostAddress + ":" + u.Port() + "\n"})
patch.RuncmdPrepend = append(patch.RuncmdPrepend, []any{"systemctl", "enable", "--now", "swc-network-" + u.Port() + ".socket"})
}
if caPEM != "" {
patch.CACertsTrusted = []string{caPEM}
}
return patch, nil
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData, Modules: []any{cloudinit.UserDataModule(module)}})
}
func InjectAcceptBundle(userData string, bundle map[string]any, acceptPath string) (string, error) {
module, err := AcceptBundle(acceptPath, bundle)
if err != nil {
return "", err
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{
Base: userData,
Modules: []any{module, PoweroffModule},
})
}
func WithGuestLogin(userData string, opts GuestLoginOptions) (string, error) {
module, err := GuestLoginModule(opts)
if err != nil {
return "", err
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData, Modules: []any{module}})
}
func WithOnNetworkReporter(userData, fallbackURL, acceptPath, bearerAudience string) (string, error) {
module, add, err := OnNetworkReporterModule(userData, fallbackURL, acceptPath, bearerAudience, "")
if err != nil || !add {
return userData, err
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData, Modules: []any{module}})
}
func WithOnNetworkBaseURL(userData, fallbackURL string) (string, error) {
module, add, err := OnNetworkBaseURLModule(userData, fallbackURL)
if err != nil || !add {
return userData, err
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData, Modules: []any{module}})
}
func Provision(opts ProvisionOptions) (string, error) {
if _, served := GuestBinaryPins(opts.Downloads, []string{GuestBinaryAgent}); opts.Memory && served == nil && strings.TrimSpace(opts.HostURL) != "" {
memory := func(cloudinit.Context) (cloudinit.UserDataPatch, error) {
return cloudinit.UserDataPatch{WriteFiles: []cloudinit.WriteFileEntry{{Path: cloudinit.GuestAgentMemoryPath, Owner: "root:root", Permissions: "0644", Content: "{}\n"}}}, nil
}
withMemory, err := cloudinit.BuildUserData(cloudinit.BuildOptions{Base: opts.UserData, Modules: []any{cloudinit.UserDataModule(memory)}})
if err != nil {
return "", err
}
opts.UserData = withMemory
}
acceptPath := opts.AcceptPath
acceptPath = cmp.Or(acceptPath, AcceptPathVM)
modules := []any{}
ctx := cloudinit.Context{SecretsAcceptPath: acceptPath}
if opts.TLSPort > 0 && opts.TLSPort <= 65535 {
opts.UserData = addGuestTLSPort(opts.UserData, opts.TLSPort)
opts.FallbackURL = addGuestTLSPort(opts.FallbackURL, opts.TLSPort)
if opts.Login != nil {
login := *opts.Login
login.URL = addGuestTLSPort(login.URL, opts.TLSPort)
opts.Login = &login
}
}
if opts.Login != nil {
module, err := GuestLoginModule(*opts.Login)
if err != nil {
return "", err
}
ctx.VMName = opts.Login.Role
modules = append(modules, module)
}
if opts.Reporter {
module, add, err := OnNetworkReporterModule(opts.UserData, opts.FallbackURL, acceptPath, opts.BearerAudience, opts.HostURL)
if err != nil {
return "", err
}
if add {
modules = append(modules, module)
}
}
if opts.BaseURL {
module, add, err := OnNetworkBaseURLModule(opts.UserData, opts.FallbackURL)
if err != nil {
return "", err
}
if add {
modules = append(modules, module)
}
}
rewritten, hostModules, err := PointAtHostModules(opts.UserData, opts.HostAddress, opts.TLSPort)
if err != nil {
return "", err
}
for _, module := range hostModules {
modules = append(modules, module)
}
binaries, err := guestBinaryModules(opts, acceptPath)
if err != nil {
return "", err
}
modules = append(modules, binaries...)
if len(modules) == 0 {
return rewritten, nil
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: rewritten, Modules: modules, Ctx: ctx})
}
func guestBinaryModules(opts ProvisionOptions, acceptPath string) ([]any, error) {
needs := GuestBinariesNeeded(opts.UserData)
if err := needs.ToolsErr(); err != nil {
return nil, err
}
if !needs.Any() {
return nil, nil
}
if strings.TrimSpace(opts.HostURL) == "" {
return nil, fmt.Errorf("guestseed: the guest asks for %s, and the bidder has no host URL to serve them from", strings.Join(needs.Names(), ", "))
}
pins, err := GuestBinaryPins(opts.Downloads, needs.Names())
if err != nil {
return nil, err
}
var out []any
if needs.Agent {
agent, err := GuestAgentModule(opts.HostURL, opts.BearerAudience, acceptPath, needs.Secrets, needs.Requester, opts.WebRTC)
if err != nil {
return nil, err
}
out = append(out, agent)
}
install, err := GuestBinariesModule(opts.HostURL, pins, needs.Units)
if err != nil {
return nil, err
}
return append(out, install), nil
}
func validateGuestLogin(opts GuestLoginOptions) error {
url := strings.TrimRight(strings.TrimSpace(opts.URL), "/")
if err := checkURLLike(url, "guest login URL"); err != nil {
return err
}
if len(opts.Role) > 201 || !guestLoginRoleRE.MatchString(opts.Role) {
return fmt.Errorf("guestseed: guest login role %q is not a ComputeVM name", opts.Role)
}
if !guestBindSecretRE.MatchString(opts.BindSecret) {
return fmt.Errorf("guestseed: guest login bind secret is not 64 lowercase hex characters")
}
mount := opts.Mount
mount = cmp.Or(mount, GuestLoginDefaultMount)
if len(mount) > 63 || !guestLoginMountRE.MatchString(mount) {
return fmt.Errorf("guestseed: guest login mount %q is not an auth mount name", mount)
}
if opts.SSHDir != "" {
if err := checkAbsolute(opts.SSHDir); err != nil {
return err
}
}
if opts.TokenPath != "" {
if err := checkAbsolute(opts.TokenPath); err != nil {
return err
}
}
if opts.Attempts < 0 || opts.Attempts > 1000 {
return fmt.Errorf("guestseed: guest login attempts %d is not between 0 and 1000", opts.Attempts)
}
if opts.RetryDelaySec < 0 || opts.RetryDelaySec > 300 {
return fmt.Errorf("guestseed: guest login retry delay %d s is not between 0 and 300", opts.RetryDelaySec)
}
return nil
}
func addGuestTLSPort(userData string, port int) string {
matches := guestLocalhostURL.FindAllStringSubmatchIndex(userData, -1)
if len(matches) == 0 {
return userData
}
var b strings.Builder
last := 0
suffix := ":" + strconv.Itoa(port)
for _, m := range matches {
end := m[1]
if end < len(userData) && hostContinuation(rune(userData[end])) {
continue
}
b.WriteString(userData[last:m[0]])
b.WriteString("https://")
b.WriteString(userData[m[2]:m[3]])
b.WriteString(suffix)
last = end
}
b.WriteString(userData[last:])
return b.String()
}
func HostPortsOf(userData string, tlsPort int) []int {
if tlsPort <= 0 || tlsPort > 65535 {
return nil
}
ports := []int{tlsPort}
for _, m := range guestHostURL.FindAllStringSubmatchIndex(userData, -1) {
if m[1] < len(userData) && hostContinuation(rune(userData[m[1]])) {
continue
}
port := 80
if strings.EqualFold(userData[m[2]:m[3]], "https") {
port = 443
}
if m[4] >= 0 {
port, _ = strconv.Atoi(userData[m[4]:m[5]])
}
ports = append(ports, port)
}
return guestnet.HostPorts(ports)
}
func hostContinuation(r rune) bool {
return r == ':' || r == '.' || r == '-' || r == '_' || (r >= '0' && r <= '9') || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z')
}
func localhostHosts(userData string) []string {
seen := map[string]bool{}
var hosts []string
for _, m := range guestAnyLocalhostURL.FindAllStringSubmatch(userData, -1) {
host := strings.ToLower(m[1])
if seen[host] {
continue
}
seen[host] = true
hosts = append(hosts, host)
}
sort.Strings(hosts)
return hosts
}
func checkAbsolute(p string) error {
if p == "" || !strings.HasPrefix(p, "/") || strings.Contains(p, "..") {
return fmt.Errorf("guestseed: %q is not an absolute path inside the guest", p)
}
if !safeInDoubleQuotes(p) {
return fmt.Errorf("guestseed: %q carries a character a shell would read", p)
}
return nil
}
func checkURLLike(raw, what string) error {
u, err := url.Parse(raw)
if err != nil || u.Host == "" || (u.Scheme != "https" && u.Scheme != "http") {
return fmt.Errorf("guestseed: %s %q is not an absolute http or https URL", what, raw)
}
if u.User != nil || u.Fragment != "" {
return fmt.Errorf("guestseed: %s %q carries a user or fragment", what, raw)
}
if !safeInDoubleQuotes(raw) {
return fmt.Errorf("guestseed: %s %q carries a character a shell would read", what, raw)
}
return nil
}
func safeInDoubleQuotes(s string) bool {
return !strings.ContainsAny(s, "\"'`$\\\n\r")
}
func shellQuote(s string) string {
return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}