// parseUserGroup parses the User and Group fields of an App and returns its
// UID and GID.
// The User and Group fields accept several formats:
// 1. the hardcoded string "root"
// 2. a path
// 3. a number
// 4. a name in reference to /etc/{group,passwd} in the image
// See https://github.com/appc/spec/blob/master/spec/aci.md#image-manifest-schema
func parseUserGroup(p *stage1commontypes.Pod, ra *schema.RuntimeApp) (int, int, error) {
var uidResolver, gidResolver user.Resolver
var uid, gid int
var err error
root := common.AppRootfsPath(p.Root, ra.Name)
uidResolver, err = user.NumericIDs(ra.App.User)
if err != nil {
uidResolver, err = user.IDsFromStat(root, ra.App.User, &p.UidRange)
}
if err != nil {
uidResolver, err = user.IDsFromEtc(root, ra.App.User, "")
}
if err != nil { // give up
return -1, -1, errwrap.Wrap(fmt.Errorf("invalid user %q", ra.App.User), err)
}
if uid, _, err = uidResolver.IDs(); err != nil {
return -1, -1, errwrap.Wrap(fmt.Errorf("failed to configure user %q", ra.App.User), err)
}
gidResolver, err = user.NumericIDs(ra.App.Group)
if err != nil {
gidResolver, err = user.IDsFromStat(root, ra.App.Group, &p.UidRange)
}
if err != nil {
gidResolver, err = user.IDsFromEtc(root, "", ra.App.Group)
}
if err != nil { // give up
return -1, -1, errwrap.Wrap(fmt.Errorf("invalid group %q", ra.App.Group), err)
}
if _, gid, err = gidResolver.IDs(); err != nil {
return -1, -1, errwrap.Wrap(fmt.Errorf("failed to configure group %q", ra.App.Group), err)
}
return uid, gid, nil
}
func stage1() int {
uuid, err := types.NewUUID(flag.Arg(0))
if err != nil {
log.Print("UUID is missing or malformed\n")
return 1
}
root := "."
p, err := stage1commontypes.LoadPod(root, uuid)
if err != nil {
log.PrintE("can't load pod", err)
return 1
}
// Sanity checks
if len(p.Manifest.Apps) != 1 {
log.Printf("flavor %q only supports 1 application per Pod for now", flavor)
return 1
}
ra := p.Manifest.Apps[0]
imgName := p.AppNameToImageName(ra.Name)
args := ra.App.Exec
if len(args) == 0 {
log.Printf(`image %q has an empty "exec" (try --exec=BINARY)`, imgName)
return 1
}
lfd, err := common.GetRktLockFD()
if err != nil {
log.PrintE("can't get rkt lock fd", err)
return 1
}
// set close-on-exec flag on RKT_LOCK_FD so it gets correctly closed after execution is finished
if err := sys.CloseOnExec(lfd, true); err != nil {
log.PrintE("can't set FD_CLOEXEC on rkt lock", err)
return 1
}
workDir := "/"
if ra.App.WorkingDirectory != "" {
workDir = ra.App.WorkingDirectory
}
env := []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"}
for _, e := range ra.App.Environment {
env = append(env, e.Name+"="+e.Value)
}
rfs := filepath.Join(common.AppPath(p.Root, ra.Name), "rootfs")
if err := copyResolv(p); err != nil {
log.PrintE("can't copy /etc/resolv.conf", err)
return 1
}
argFlyMounts, err := evaluateMounts(rfs, string(ra.Name), p)
if err != nil {
log.PrintE("can't evaluate mounts", err)
return 1
}
effectiveMounts := append(
[]flyMount{
{"", "", "/dev", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/dev", rfs, "/dev", "none", syscall.MS_BIND | syscall.MS_REC},
{"", "", "/proc", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/proc", rfs, "/proc", "none", syscall.MS_BIND | syscall.MS_REC},
{"", "", "/sys", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/sys", rfs, "/sys", "none", syscall.MS_BIND | syscall.MS_REC},
{"tmpfs", rfs, "/tmp", "tmpfs", 0},
},
argFlyMounts...,
)
for _, mount := range effectiveMounts {
var (
err error
hostPathInfo os.FileInfo
targetPathInfo os.FileInfo
)
if strings.HasPrefix(mount.HostPath, "/") {
if hostPathInfo, err = os.Stat(mount.HostPath); err != nil {
log.PrintE(fmt.Sprintf("stat of host path %s", mount.HostPath), err)
return 1
}
} else {
hostPathInfo = nil
}
absTargetPath := filepath.Join(mount.TargetPrefixPath, mount.RelTargetPath)
if targetPathInfo, err = os.Stat(absTargetPath); err != nil && !os.IsNotExist(err) {
log.PrintE(fmt.Sprintf("stat of target path %s", absTargetPath), err)
return 1
}
switch {
case targetPathInfo == nil:
absTargetPathParent, _ := filepath.Split(absTargetPath)
if err := os.MkdirAll(absTargetPathParent, 0755); err != nil {
log.PrintE(fmt.Sprintf("can't create directory %q", absTargetPath), err)
return 1
}
switch {
case hostPathInfo == nil || hostPathInfo.IsDir():
if err := os.Mkdir(absTargetPath, 0755); err != nil {
log.PrintE(fmt.Sprintf("can't create directory %q", absTargetPath), err)
return 1
}
case !hostPathInfo.IsDir():
file, err := os.OpenFile(absTargetPath, os.O_CREATE, 0700)
if err != nil {
log.PrintE(fmt.Sprintf("can't create file %q", absTargetPath), err)
return 1
}
file.Close()
}
case hostPathInfo != nil:
switch {
case hostPathInfo.IsDir() && !targetPathInfo.IsDir():
log.Printf("can't mount because %q is a directory while %q is not", mount.HostPath, absTargetPath)
return 1
case !hostPathInfo.IsDir() && targetPathInfo.IsDir():
log.Printf("can't mount because %q is not a directory while %q is", mount.HostPath, absTargetPath)
return 1
}
}
if err := syscall.Mount(mount.HostPath, absTargetPath, mount.Fs, mount.Flags, ""); err != nil {
log.PrintE(fmt.Sprintf("can't mount %q on %q with flags %v", mount.HostPath, absTargetPath, mount.Flags), err)
return 1
}
}
if err = stage1common.WritePid(os.Getpid(), "pid"); err != nil {
log.Error(err)
return 1
}
var uidResolver, gidResolver user.Resolver
var uid, gid int
uidResolver, err = user.NumericIDs(ra.App.User)
if err != nil {
uidResolver, err = user.IDsFromStat(rfs, ra.App.User, nil)
}
if err != nil { // give up
log.PrintE(fmt.Sprintf("invalid user %q", ra.App.User), err)
return 1
}
if uid, _, err = uidResolver.IDs(); err != nil {
log.PrintE(fmt.Sprintf("failed to configure user %q", ra.App.User), err)
return 1
}
gidResolver, err = user.NumericIDs(ra.App.Group)
if err != nil {
gidResolver, err = user.IDsFromStat(rfs, ra.App.Group, nil)
}
if err != nil { // give up
log.PrintE(fmt.Sprintf("invalid group %q", ra.App.Group), err)
return 1
}
if _, gid, err = gidResolver.IDs(); err != nil {
log.PrintE(fmt.Sprintf("failed to configure group %q", ra.App.Group), err)
return 1
}
diag.Printf("chroot to %q", rfs)
if err := syscall.Chroot(rfs); err != nil {
log.PrintE("can't chroot", err)
return 1
}
if err := os.Chdir(workDir); err != nil {
log.PrintE(fmt.Sprintf("can't change to working directory %q", workDir), err)
return 1
}
// lock the current goroutine to its current OS thread.
// This will force the subsequent syscalls to be executed in the same OS thread as Setresuid, and Setresgid,
// see https://github.com/golang/go/issues/1435#issuecomment-66054163.
runtime.LockOSThread()
diag.Printf("setting uid %d gid %d", uid, gid)
if err := syscall.Setresgid(gid, gid, gid); err != nil {
log.PrintE(fmt.Sprintf("can't set gid %d", gid), err)
return 1
}
if err := syscall.Setresuid(uid, uid, uid); err != nil {
log.PrintE(fmt.Sprintf("can't set uid %d", uid), err)
return 1
}
diag.Printf("execing %q in %q", args, rfs)
err = stage1common.WithClearedCloExec(lfd, func() error {
return syscall.Exec(args[0], args, env)
})
if err != nil {
log.PrintE(fmt.Sprintf("can't execute %q", args[0]), err)
return 1
}
return 0
}
func stage1(rp *stage1commontypes.RuntimePod) int {
uuid, err := types.NewUUID(flag.Arg(0))
if err != nil {
log.Print("UUID is missing or malformed\n")
return 254
}
root := "."
p, err := stage1commontypes.LoadPod(root, uuid, rp)
if err != nil {
log.PrintE("can't load pod", err)
return 254
}
if err := p.SaveRuntime(); err != nil {
log.FatalE("failed to save runtime parameters", err)
}
// Sanity checks
if len(p.Manifest.Apps) != 1 {
log.Printf("flavor %q only supports 1 application per Pod for now", flavor)
return 254
}
ra := p.Manifest.Apps[0]
imgName := p.AppNameToImageName(ra.Name)
args := ra.App.Exec
if len(args) == 0 {
log.Printf(`image %q has an empty "exec" (try --exec=BINARY)`, imgName)
return 254
}
lfd, err := common.GetRktLockFD()
if err != nil {
log.PrintE("can't get rkt lock fd", err)
return 254
}
// set close-on-exec flag on RKT_LOCK_FD so it gets correctly closed after execution is finished
if err := sys.CloseOnExec(lfd, true); err != nil {
log.PrintE("can't set FD_CLOEXEC on rkt lock", err)
return 254
}
workDir := "/"
if ra.App.WorkingDirectory != "" {
workDir = ra.App.WorkingDirectory
}
env := []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"}
for _, e := range ra.App.Environment {
env = append(env, e.Name+"="+e.Value)
}
rfs := filepath.Join(common.AppPath(p.Root, ra.Name), "rootfs")
argFlyMounts, err := evaluateMounts(rfs, string(ra.Name), p)
if err != nil {
log.PrintE("can't evaluate mounts", err)
return 254
}
effectiveMounts := append(
[]flyMount{
{"", "", "/dev", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/dev", rfs, "/dev", "none", syscall.MS_BIND | syscall.MS_REC},
{"", "", "/proc", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/proc", rfs, "/proc", "none", syscall.MS_BIND | syscall.MS_REC},
{"", "", "/sys", "none", syscall.MS_REC | syscall.MS_SHARED},
{"/sys", rfs, "/sys", "none", syscall.MS_BIND | syscall.MS_REC},
{"tmpfs", rfs, "/tmp", "tmpfs", 0},
},
argFlyMounts...,
)
/* Process DNS config files
*
* /etc/resolv.conf: four modes
* 'host' - bind-mount host's file
* 'stage0' - bind-mount the file created by stage0
* 'default' - do nothing (we would respect CNI if fly had networking)
* 'none' - do nothing
*/
switch p.ResolvConfMode {
case "host":
effectiveMounts = append(effectiveMounts,
flyMount{"/etc/resolv.conf", rfs, "/etc/resolv.conf", "none", syscall.MS_BIND | syscall.MS_RDONLY})
case "stage0":
if err := copyResolv(p); err != nil {
log.PrintE("can't copy /etc/resolv.conf", err)
return 254
}
}
/*
* /etc/hosts: three modes:
* 'host' - bind-mount hosts's file
* 'stage0' - bind mount the file created by stage1
* 'default' - create a stub /etc/hosts if needed
*/
switch p.EtcHostsMode {
case "host":
effectiveMounts = append(effectiveMounts,
flyMount{"/etc/hosts", rfs, "/etc/hosts", "none", syscall.MS_BIND | syscall.MS_RDONLY})
case "stage0":
effectiveMounts = append(effectiveMounts, flyMount{
filepath.Join(common.Stage1RootfsPath(p.Root), "etc", "rkt-hosts"),
rfs,
"/etc/hosts",
"none",
syscall.MS_BIND | syscall.MS_RDONLY})
case "default":
stage2HostsPath := filepath.Join(common.AppRootfsPath(p.Root, ra.Name), "etc", "hosts")
if _, err := os.Stat(stage2HostsPath); err != nil && os.IsNotExist(err) {
fallbackHosts := []byte("127.0.0.1 localhost localdomain\n")
ioutil.WriteFile(stage2HostsPath, fallbackHosts, 0644)
}
}
for _, mount := range effectiveMounts {
diag.Printf("Processing %+v", mount)
var (
err error
hostPathInfo os.FileInfo
targetPathInfo os.FileInfo
)
if strings.HasPrefix(mount.HostPath, "/") {
if hostPathInfo, err = os.Stat(mount.HostPath); err != nil {
log.PrintE(fmt.Sprintf("stat of host path %s", mount.HostPath), err)
return 254
}
} else {
hostPathInfo = nil
}
absTargetPath := filepath.Join(mount.TargetPrefixPath, mount.RelTargetPath)
if targetPathInfo, err = os.Stat(absTargetPath); err != nil && !os.IsNotExist(err) {
log.PrintE(fmt.Sprintf("stat of target path %s", absTargetPath), err)
return 254
}
switch {
case (mount.Flags & syscall.MS_REMOUNT) != 0:
{
diag.Printf("don't attempt to create files for remount of %q", absTargetPath)
}
case targetPathInfo == nil:
absTargetPathParent, _ := filepath.Split(absTargetPath)
if err := os.MkdirAll(absTargetPathParent, 0755); err != nil {
log.PrintE(fmt.Sprintf("can't create directory %q", absTargetPath), err)
return 254
}
switch {
case hostPathInfo == nil || hostPathInfo.IsDir():
if err := os.Mkdir(absTargetPath, 0755); err != nil {
log.PrintE(fmt.Sprintf("can't create directory %q", absTargetPath), err)
return 254
}
case !hostPathInfo.IsDir():
file, err := os.OpenFile(absTargetPath, os.O_CREATE, 0700)
if err != nil {
log.PrintE(fmt.Sprintf("can't create file %q", absTargetPath), err)
return 254
}
file.Close()
}
case hostPathInfo != nil:
switch {
case hostPathInfo.IsDir() && !targetPathInfo.IsDir():
log.Printf("can't mount because %q is a directory while %q is not", mount.HostPath, absTargetPath)
return 254
case !hostPathInfo.IsDir() && targetPathInfo.IsDir():
log.Printf("can't mount because %q is not a directory while %q is", mount.HostPath, absTargetPath)
return 254
}
}
if err := syscall.Mount(mount.HostPath, absTargetPath, mount.Fs, mount.Flags, ""); err != nil {
log.PrintE(fmt.Sprintf("can't mount %q on %q with flags %v", mount.HostPath, absTargetPath, mount.Flags), err)
return 254
}
}
if err = stage1common.WritePid(os.Getpid(), "pid"); err != nil {
log.Error(err)
return 254
}
var uidResolver, gidResolver user.Resolver
var uid, gid int
uidResolver, err = user.NumericIDs(ra.App.User)
if err != nil {
uidResolver, err = user.IDsFromStat(rfs, ra.App.User, nil)
}
if err != nil { // give up
log.PrintE(fmt.Sprintf("invalid user %q", ra.App.User), err)
return 254
}
if uid, _, err = uidResolver.IDs(); err != nil {
log.PrintE(fmt.Sprintf("failed to configure user %q", ra.App.User), err)
return 254
}
gidResolver, err = user.NumericIDs(ra.App.Group)
if err != nil {
gidResolver, err = user.IDsFromStat(rfs, ra.App.Group, nil)
}
if err != nil { // give up
log.PrintE(fmt.Sprintf("invalid group %q", ra.App.Group), err)
return 254
}
if _, gid, err = gidResolver.IDs(); err != nil {
log.PrintE(fmt.Sprintf("failed to configure group %q", ra.App.Group), err)
return 254
}
diag.Printf("chroot to %q", rfs)
if err := syscall.Chroot(rfs); err != nil {
log.PrintE("can't chroot", err)
return 254
}
if err := os.Chdir(workDir); err != nil {
log.PrintE(fmt.Sprintf("can't change to working directory %q", workDir), err)
return 254
}
// lock the current goroutine to its current OS thread.
// This will force the subsequent syscalls to be executed in the same OS thread as Setresuid, and Setresgid,
// see https://github.com/golang/go/issues/1435#issuecomment-66054163.
runtime.LockOSThread()
diag.Printf("setting uid %d gid %d", uid, gid)
if err := syscall.Setresgid(gid, gid, gid); err != nil {
log.PrintE(fmt.Sprintf("can't set gid %d", gid), err)
return 254
}
if err := syscall.Setresuid(uid, uid, uid); err != nil {
log.PrintE(fmt.Sprintf("can't set uid %d", uid), err)
return 254
}
diag.Printf("execing %q in %q", args, rfs)
err = stage1common.WithClearedCloExec(lfd, func() error {
return syscall.Exec(args[0], args, env)
})
if err != nil {
log.PrintE(fmt.Sprintf("can't execute %q", args[0]), err)
return 254
}
return 0
}
func TestStat(t *testing.T) {
tmp, err := ioutil.TempFile("", "rkt-TestStat-")
if err != nil {
panic(err)
}
defer os.Remove(tmp.Name())
rng := user.NewBlankUidRange()
rng.SetRandomUidRange(100)
u, err := osuser.Current()
if err != nil {
panic(err)
}
procUid, err := strconv.Atoi(u.Uid)
if err != nil {
panic(err)
}
procGid, err := strconv.Atoi(u.Gid)
if err != nil {
panic(err)
}
for i, tt := range []struct {
root, path string
// expected
errIDs, err bool
uid, gid int
}{
{
root: "",
path: "",
err: true,
},
{
root: "unknown",
path: "",
err: true,
},
{
root: "",
path: "unknown",
err: true,
},
{
root: "",
path: tmp.Name(),
uid: procUid,
gid: procGid,
},
{
root: "/",
path: tmp.Name(),
uid: procUid,
gid: procGid,
},
{
root: "unknown",
path: tmp.Name(),
errIDs: true,
uid: -1,
gid: -1,
},
{
root: filepath.Dir(tmp.Name()),
path: "",
err: true,
},
{
root: filepath.Dir(tmp.Name()),
path: "/" + filepath.Base(tmp.Name()),
uid: procUid,
gid: procGid,
},
{
root: filepath.Dir(tmp.Name()),
path: "/unknown",
errIDs: true,
uid: -1,
gid: -1,
},
{
root: filepath.Dir(tmp.Name()),
path: "unknown",
err: true,
},
} {
gen, err := user.IDsFromStat(tt.root, tt.path, nil)
if err == nil && tt.err {
t.Errorf("test %d: expected error but got one", i)
}
if err != nil {
continue
}
uid, gid, err := gen.IDs()
if err == nil && tt.errIDs {
t.Errorf("test %d: expected err but got none", i)
}
if uid != tt.uid {
t.Errorf("test %d: expected uid %d but got %d", i, tt.uid, uid)
}
if gid != tt.gid {
t.Errorf("test %d: expected gid %d but got %d", i, tt.gid, gid)
}
}
}