0
0
//go:build linux
package hostcontract
import (
"bufio"
"bytes"
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"io"
"os"
"os/exec"
"os/user"
"path/filepath"
"strconv"
"strings"
"syscall"
"time"
"golang.org/x/sys/unix"
"github.com/johnandersen777/socialweb-computer-kcp/internal/assets"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
)
type Options struct {
Role Role
StateDir string
Self []string
PastaPath string
AssetCache string
Getenv func(string) string
}
const (
ProbeHoldFlag = "-probe-hold"
ProbeUsernsFlag = "-probe-userns"
childTimeout = 20 * time.Second
)
func Gather(ctx context.Context, o Options) Facts {
uid := os.Getuid()
f := Facts{Role: o.Role, UID: uid, Euid: os.Geteuid(), StateDir: o.StateDir}
if u, err := user.LookupId(strconv.Itoa(uid)); err == nil {
f.Account = u.Username
}
f.RuntimeDir = o.Getenv("XDG_RUNTIME_DIR")
if f.RuntimeDir == "" {
f.RuntimeDir = filepath.Join("/run/user", strconv.Itoa(uid))
}
socket := filepath.Join(f.RuntimeDir, "systemd", "private")
if v, err := hostsvc.ManagerVersion(ctx, socket); err != nil {
f.VersionErr = err.Error()
} else {
f.SystemdVersion = v
gatherProbe(ctx, &f, o, socket)
}
f.CgroupV2 = cgroup2()
mgr := filepath.Join("/sys/fs/cgroup/user.slice", fmt.Sprintf("user-%d.slice", uid), fmt.Sprintf("user@%d.service", uid))
if b, err := os.ReadFile(filepath.Join(mgr, "cgroup.controllers")); err != nil {
f.ManagerControllersErr = err.Error()
} else {
f.ManagerControllers = strings.Fields(string(b))
}
_, err := os.Stat(filepath.Join(o.Getenv(StagedRootEnv), "/var/lib/systemd/linger", f.Account))
f.Linger = err == nil && f.Account != ""
if b, err := os.ReadFile("/proc/sys/kernel/random/boot_id"); err == nil {
f.BootID = strings.TrimSpace(string(b))
}
f.Tzdata = fsx.Exists("/usr/share/zoneinfo/UTC")
if st, err := os.Stat("/etc/rancher"); err == nil && st.IsDir() {
f.RancherEtc = true
}
f.OomdActive = nonEmpty("/sys/fs/cgroup/system.slice/systemd-oomd.service/cgroup.procs")
if o.Role != RoleBidder {
return f
}
f.KVMMissing = !fsx.Exists("/dev/kvm")
f.KVMErr = openRW("/dev/kvm")
f.TunErr = openRW("/dev/net/tun")
f.KVMGid, f.AccountInKVM = groupMembership("/etc/group", "kvm", f.Account)
f.ManagerPID, f.ManagerGroups, f.ManagerErr = ManagerGroups("/", uid)
if b, err := os.ReadFile("/proc/sys/kernel/apparmor_restrict_unprivileged_userns"); err == nil {
f.AppArmorRestricts = strings.TrimSpace(string(b)) == "1"
}
if f.AppArmorRestricts {
b, err := os.ReadFile("/sys/kernel/security/apparmor/profiles")
if err != nil {
f.AppArmorErr = err.Error()
}
f.AppArmorLoaded = AppArmorProfileLoaded(string(b), AppArmorProfileName)
}
sub, _ := os.ReadFile("/etc/subuid")
sg, _ := os.ReadFile("/etc/subgid")
f.Subuid, f.Subgid = string(sub), string(sg)
f.Helpers = helpers()
gatherUIDMap(ctx, &f, o)
gatherPasta(ctx, &f, o)
f.ACLChecked, f.ACLErr = aclSupported(o.StateDir)
return f
}
func GatherRequesterGateway(o Options) Facts {
uid := os.Getuid()
f := Facts{Role: RoleGateway, UID: uid, Euid: os.Geteuid(), StateDir: o.StateDir}
if u, err := user.LookupId(strconv.Itoa(uid)); err == nil {
f.Account = u.Username
}
f.CgroupV2 = cgroup2()
mgr := filepath.Join("/sys/fs/cgroup/user.slice", fmt.Sprintf("user-%d.slice", uid), fmt.Sprintf("user@%d.service", uid))
if b, err := os.ReadFile(filepath.Join(mgr, "cgroup.controllers")); err != nil {
f.ManagerControllersErr = err.Error()
} else {
f.ManagerControllers = strings.Fields(string(b))
}
f.Tzdata = fsx.Exists("/usr/share/zoneinfo/UTC")
if st, err := os.Stat("/etc/rancher"); err == nil && st.IsDir() {
f.RancherEtc = true
}
sub, _ := os.ReadFile("/etc/subuid")
sg, _ := os.ReadFile("/etc/subgid")
f.Subuid, f.Subgid = string(sub), string(sg)
f.Helpers = helpers()
return f
}
func randomSuffix() string {
b := make([]byte, 6)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
func gatherProbe(ctx context.Context, f *Facts, o Options, socket string) {
if len(o.Self) == 0 || o.StateDir == "" {
f.ProbeErr = "no executable or state dir to probe with"
return
}
suffix := randomSuffix()
dir := filepath.Join(o.StateDir, "probe", suffix)
if err := os.MkdirAll(dir, 0o700); err != nil {
f.ProbeErr = err.Error()
return
}
defer os.RemoveAll(dir)
out := filepath.Join(dir, "probe.log")
spec, extra := ProbeSpec(o.Role, suffix, append(append([]string(nil), o.Self...), ProbeHoldFlag), out)
r, err := hostsvc.Probe(ctx, socket, spec, extra)
f.ProbeSent, f.ProbeReadBack = r.Sent, r.ReadBack
if err != nil {
f.ProbeErr = err.Error()
} else if r.Result != "done" {
f.ProbeErr = "the start job ended " + r.Result
}
}
func cgroup2() bool {
var st unix.Statfs_t
if err := unix.Statfs("/sys/fs/cgroup", &st); err != nil {
return false
}
return st.Type == unix.CGROUP2_SUPER_MAGIC
}
func nonEmpty(p string) bool {
b, err := os.ReadFile(p)
return err == nil && len(bytes.TrimSpace(b)) > 0
}
func openRW(p string) string {
fh, err := os.OpenFile(p, os.O_RDWR, 0)
if err != nil {
return err.Error()
}
fh.Close()
return ""
}
func groupMembership(path, group, account string) (int, bool) {
b, err := os.ReadFile(path)
if err != nil {
return -1, false
}
return GroupMembership(string(b), group, account)
}
func helpers() []Helper {
up, uerr := exec.LookPath("newuidmap")
gp, gerr := exec.LookPath("newgidmap")
return []Helper{helperAt("newuidmap", up, uerr), helperAt("newgidmap", gp, gerr)}
}
func helperAt(name, p string, err error) Helper {
h := Helper{Name: name}
if err != nil {
h.Err = "not found on PATH"
return h
}
h.Path = p
st, err := os.Stat(p)
if err != nil {
h.Err = err.Error()
return h
}
sys, ok := st.Sys().(*syscall.Stat_t)
h.Setuid = ok && sys.Uid == 0 && st.Mode()&os.ModeSetuid != 0
if n, err := unix.Getxattr(p, "security.capability", nil); err == nil && n > 0 {
h.Caps = true
}
return h
}
func aclSupported(dir string) (bool, string) {
if dir == "" {
return false, "no state dir given"
}
_, err := unix.Getxattr(dir, "system.posix_acl_access", nil)
switch {
case err == nil, errors.Is(err, unix.ENODATA):
return true, ""
case errors.Is(err, unix.ENOTSUP):
return true, "the filesystem does not support POSIX ACLs"
}
return true, err.Error()
}
func gatherPasta(ctx context.Context, f *Facts, o Options) {
paths := map[string]string{}
if o.PastaPath != "" {
paths["pasta"] = o.PastaPath
}
e, err := assets.Resolve(assets.Options{Cache: o.AssetCache, Paths: paths}, "pasta")
if err != nil {
f.PastaErr = err.Error()
return
}
f.PastaChecked = true
if len(o.Self) == 0 {
f.PastaErr = "no executable to exec inside the namespace"
return
}
ctx, cancel := context.WithTimeout(ctx, childTimeout)
defer cancel()
var quoted []string
for _, a := range append(append([]string(nil), o.Self...), "-probe-exec") {
quoted = append(quoted, "'"+strings.ReplaceAll(a, "'", `'\''`)+"'")
}
inner := strings.Join(quoted, " ")
cmd := exec.CommandContext(ctx, e.Path, "--quiet", "--", "/bin/sh", "-c", "exec "+inner)
cmd.Env = append(os.Environ(), e.Env...)
if out, err := cmd.CombinedOutput(); err != nil {
f.PastaErr = fmt.Sprintf("%v: %s", err, strings.TrimSpace(string(out)))
}
}
func gatherUIDMap(ctx context.Context, f *Facts, o Options) {
if len(SubidProblems(f.Subuid, f.Subgid, f.Account, f.UID)) > 0 {
f.UIDMapErr = "the account has no usable subuid/subgid range"
return
}
for _, h := range f.Helpers {
if h.Err != "" {
f.UIDMapErr = h.Name + " " + h.Err
return
}
}
if len(o.Self) == 0 {
f.UIDMapErr = "no executable to run as the namespace's init"
return
}
f.UIDMapChecked = true
ur, _ := AccountRange(f.Subuid, f.Account, f.UID)
gr, _ := AccountRange(f.Subgid, f.Account, f.UID)
f.UIDMapErr = MapThrowaway(ctx, o.Self, f.Helpers[0].Path, f.Helpers[1].Path, ur.Start, gr.Start)
}
func MapThrowaway(ctx context.Context, self []string, newuidmap, newgidmap string, uidStart, gidStart uint64) string {
ctx, cancel := context.WithTimeout(ctx, childTimeout)
defer cancel()
cmd := exec.CommandContext(ctx, self[0], append(append([]string(nil), self[1:]...), ProbeUsernsFlag)...)
cmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUSER, Pdeathsig: syscall.SIGKILL}
stdin, err := cmd.StdinPipe()
if err != nil {
return err.Error()
}
var out bytes.Buffer
cmd.Stdout, cmd.Stderr = &out, &out
if err := cmd.Start(); err != nil {
return "starting a child in a new user namespace: " + err.Error()
}
pid := strconv.Itoa(cmd.Process.Pid)
count := strconv.Itoa(VMSlotIDs)
var problems []string
for _, m := range []struct{ helper, start string }{{newuidmap, strconv.FormatUint(uidStart, 10)}, {newgidmap, strconv.FormatUint(gidStart, 10)}} {
if b, err := exec.CommandContext(ctx, m.helper, pid, "0", m.start, count).CombinedOutput(); err != nil {
problems = append(problems, fmt.Sprintf("%s: %v: %s", filepath.Base(m.helper), err, strings.TrimSpace(string(b))))
}
}
_, _ = io.WriteString(stdin, "\n")
stdin.Close()
werr := cmd.Wait()
if len(problems) > 0 {
return strings.Join(problems, "; ")
}
if werr != nil {
return fmt.Sprintf("the namespace child: %v: %s", werr, strings.TrimSpace(out.String()))
}
want := []string{"0 " + strconv.FormatUint(uidStart, 10) + " " + count, "0 " + strconv.FormatUint(gidStart, 10) + " " + count}
got := strings.Join(strings.Fields(out.String()), " ")
for _, w := range want {
if !strings.Contains(got, w) {
return "the child's maps read " + got + ", want " + strings.Join(want, " and ")
}
}
return ""
}
func UsernsChild(stdin io.Reader, stdout io.Writer) int {
_, _ = bufio.NewReader(stdin).ReadString('\n')
for _, p := range []string{"/proc/self/uid_map", "/proc/self/gid_map"} {
b, err := os.ReadFile(p)
if err != nil {
fmt.Fprintln(stdout, err)
return 1
}
_, _ = stdout.Write(b)
}
return 0
}