0
0
package devcheck
import (
"bufio"
"fmt"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
)
type Status string
const (
StatusOK Status = "ok"
StatusWarn Status = "warn"
StatusFail Status = "fail"
)
const (
CheckNotRoot = "not-root"
CheckRuntimeDir = "xdg-runtime-dir"
CheckKVM = "dev-kvm"
CheckTun = "dev-net-tun"
CheckUserns = "unprivileged-userns"
CheckAppArmorUserns = "apparmor-userns-restriction"
CheckNewuidmap = "newuidmap-newgidmap"
CheckSubuid = "subuid-subgid"
CheckLogindKill = "logind-kill-user-processes"
)
var Names = []string{CheckNotRoot, CheckRuntimeDir, CheckKVM, CheckTun, CheckUserns, CheckAppArmorUserns,
CheckNewuidmap, CheckSubuid, CheckLogindKill}
type Env interface {
LookupEnv(key string) (string, bool)
}
type Host struct {
Root string
Euid int
User string
Env Env
LookPath func(name string) (string, error)
}
type Result struct {
Name string `json:"name"`
Status Status `json:"status"`
Needed string `json:"neededBy"`
Detail string `json:"detail"`
Fix string `json:"fix,omitempty"`
}
func (h Host) path(p string) string { return filepath.Join(h.Root, p) }
func (h Host) read(p string) (string, bool) {
b, err := os.ReadFile(h.path(p))
if err != nil {
return "", false
}
return strings.TrimSpace(string(b)), true
}
func (h Host) readWrite(p string) error {
f, err := os.OpenFile(h.path(p), os.O_RDWR, 0)
if err != nil {
return err
}
return f.Close()
}
func Failed(rs []Result) bool {
for _, r := range rs {
if r.Status == StatusFail {
return true
}
}
return false
}
func Run(h Host) []Result { return hostChecks(h) }
func notRoot(h Host) Result {
r := Result{Name: CheckNotRoot, Needed: "every dev verb", Status: StatusOK, Detail: "euid " + strconv.Itoa(h.Euid)}
if h.Euid == 0 {
r.Status, r.Fix = StatusFail, "run dev as your own user; dev mode needs no root and production uses install"
}
return r
}
func device(h Host, name, dev, needed, fix string) Result {
r := Result{Name: name, Needed: needed, Status: StatusOK, Detail: dev + " is readable and writable"}
if err := h.readWrite(dev); err != nil {
r.Status, r.Detail, r.Fix = StatusFail, err.Error(), fix
}
return r
}
func userns(h Host) Result {
r := Result{Name: CheckUserns, Needed: "pasta and per-VM user namespaces", Status: StatusOK}
maxNS, ok := h.read("/proc/sys/user/max_user_namespaces")
n, err := strconv.Atoi(maxNS)
if !ok || err != nil || n <= 0 {
r.Status, r.Detail = StatusFail, "user.max_user_namespaces is "+maxNS
r.Fix = "sysctl user.max_user_namespaces to a positive value (root)"
return r
}
r.Detail = "user.max_user_namespaces=" + maxNS
if v, ok := h.read("/proc/sys/kernel/unprivileged_userns_clone"); ok && v != "1" {
r.Status, r.Detail = StatusFail, "kernel.unprivileged_userns_clone="+v
r.Fix = "sysctl kernel.unprivileged_userns_clone=1 (root)"
}
return r
}
func apparmor(h Host) Result {
r := Result{Name: CheckAppArmorUserns, Needed: "pasta (Ubuntu 24.04+)", Status: StatusOK}
v, ok := h.read("/proc/sys/kernel/apparmor_restrict_unprivileged_userns")
switch {
case !ok:
r.Detail = "no AppArmor userns restriction on this kernel"
case v == "1":
r.Status, r.Detail = StatusWarn, "kernel.apparmor_restrict_unprivileged_userns=1 (dev reports it; AppArmor in dev is report-only)"
r.Fix = "install the AppArmor profile granting userns to the pinned pasta path (install does it in production), or sysctl the restriction off (root)"
default:
r.Detail = "kernel.apparmor_restrict_unprivileged_userns=" + v
}
return r
}
func newuidmap(h Host) Result {
r := Result{Name: CheckNewuidmap, Needed: "per-VM subuid user namespaces", Status: StatusOK}
var found, missing []string
for _, n := range []string{"newuidmap", "newgidmap"} {
p, err := h.LookPath(n)
if err != nil {
missing = append(missing, n)
continue
}
found = append(found, p)
}
r.Detail = strings.Join(found, " ")
if len(missing) > 0 {
r.Status, r.Detail = StatusFail, "not found: "+strings.Join(missing, " ")
r.Fix = "install the uidmap (Debian/Ubuntu) or shadow-utils (Fedora) package (root)"
}
return r
}
func hasRange(content, user string, uid int) bool {
for line := range strings.SplitSeq(content, "\n") {
f := strings.Split(strings.TrimSpace(line), ":")
if len(f) == 3 && (f[0] == user || f[0] == strconv.Itoa(uid)) {
return true
}
}
return false
}
func subuid(h Host) Result {
r := Result{Name: CheckSubuid, Needed: "per-VM subuid user namespaces", Status: StatusOK}
var missing []string
for _, f := range []string{"/etc/subuid", "/etc/subgid"} {
c, _ := h.read(f)
if !hasRange(c, h.User, h.Euid) {
missing = append(missing, f)
}
}
r.Detail = "a range for " + h.User + " in /etc/subuid and /etc/subgid"
if len(missing) > 0 {
r.Status, r.Detail = StatusFail, "no range for "+h.User+" in "+strings.Join(missing, " ")
r.Fix = fmt.Sprintf("usermod --add-subuids 100000-165535 --add-subgids 100000-165535 %s (root)", h.User)
}
return r
}
func logindSetting(h Host) (string, string) {
files := []string{"/usr/lib/systemd/logind.conf", "/etc/systemd/logind.conf"}
for _, dir := range []string{"/usr/lib/systemd/logind.conf.d", "/etc/systemd/logind.conf.d"} {
matches, _ := filepath.Glob(filepath.Join(h.path(dir), "*.conf"))
sort.Strings(matches)
for _, m := range matches {
rel, _ := filepath.Rel(h.Root, m)
files = append(files, "/"+rel)
}
}
value, from := "", ""
for _, f := range files {
fh, err := os.Open(h.path(f))
if err != nil {
continue
}
sc := bufio.NewScanner(fh)
for sc.Scan() {
k, v, ok := strings.Cut(strings.TrimSpace(sc.Text()), "=")
if ok && strings.TrimSpace(k) == "KillUserProcesses" {
value, from = strings.TrimSpace(v), f
}
}
fh.Close()
}
return value, from
}
func logind(h Host) Result {
r := Result{Name: CheckLogindKill, Needed: "a detached devsup surviving logout", Status: StatusOK}
v, from := logindSetting(h)
switch strings.ToLower(v) {
case "yes", "true", "1", "on":
r.Status, r.Detail = StatusWarn, "KillUserProcesses="+v+" in "+from+": a detached devsup dies at logout"
r.Fix = "use dev up --fg, or set KillUserProcesses=no in logind.conf (root)"
case "":
r.Detail = "KillUserProcesses unset (compiled default no on this distribution family)"
default:
r.Detail = "KillUserProcesses=" + v + " in " + from
}
return r
}