cmd/finit/main.go

@@ -1,18 +1,19 @@
 package main
 
 import (
+	"encoding/gob"
 	"errors"
 	"os"
 	"os/exec"
 	"os/signal"
 	"path"
+	"strconv"
 	"syscall"
 	"time"
 
 	init0 "git.ophivana.moe/security/fortify/cmd/finit/ipc"
 	"git.ophivana.moe/security/fortify/internal"
 	"git.ophivana.moe/security/fortify/internal/fmsg"
-	"git.ophivana.moe/security/fortify/internal/proc"
 )
 
 const (
@@ -47,24 +48,30 @@ func main() {
 		}
 	}
 
-	// receive setup payload
+	// setup pipe fd from environment
-	var (
+	var setup *os.File
-		payload    init0.Payload
+	if s, ok := os.LookupEnv(init0.Env); !ok {
-		closeSetup func() error
+		fmsg.Fatal("FORTIFY_INIT not set")
-	)
+		panic("unreachable")
-	if f, err := proc.Receive(init0.Env, &payload); err != nil {
+	} else {
-		if errors.Is(err, proc.ErrInvalid) {
+		if fd, err := strconv.Atoi(s); err != nil {
-			fmsg.Fatal("invalid config descriptor")
+			fmsg.Fatalf("cannot parse %q: %v", s, err)
-		}
+			panic("unreachable")
-		if errors.Is(err, proc.ErrNotSet) {
+		} else {
-			fmsg.Fatal("FORTIFY_INIT not set")
+			setup = os.NewFile(uintptr(fd), "setup")
+			if setup == nil {
+				fmsg.Fatal("invalid config descriptor")
+				panic("unreachable")
+			}
 		}
+	}
 
-		fmsg.Fatalf("cannot decode init setup payload: %v", err)
+	var payload init0.Payload
+	if err := gob.NewDecoder(setup).Decode(&payload); err != nil {
+		fmsg.Fatal("cannot decode init setup payload:", err)
 		panic("unreachable")
 	} else {
 		fmsg.SetVerbose(payload.Verbose)
-		closeSetup = f
 
 		// child does not need to see this
 		if err = os.Unsetenv(init0.Env); err != nil {
@@ -91,7 +98,7 @@ func main() {
 	fmsg.Suspend()
 
 	// close setup pipe as setup is now complete
-	if err := closeSetup(); err != nil {
+	if err := setup.Close(); err != nil {
 		fmsg.Println("cannot close setup pipe:", err)
 		// not fatal
 	}

cmd/fshim/ipc/payload.go

@@ -1,7 +1,11 @@
 package shim0
 
 import (
+	"encoding/gob"
+	"net"
+
 	"git.ophivana.moe/security/fortify/helper/bwrap"
+	"git.ophivana.moe/security/fortify/internal/fmsg"
 )
 
 const Env = "FORTIFY_SHIM"
@@ -19,3 +23,13 @@ type Payload struct {
 	// verbosity pass through
 	Verbose bool
 }
+
+func (p *Payload) Serve(conn *net.UnixConn) error {
+	if err := gob.NewEncoder(conn).Encode(*p); err != nil {
+		return fmsg.WrapErrorSuffix(err,
+			"cannot stream shim payload:")
+	}
+
+	return fmsg.WrapErrorSuffix(conn.Close(),
+		"cannot close setup connection:")
+}

cmd/fshim/ipc/shim/shim.go

@@ -1,16 +1,18 @@
 package shim
 
 import (
-	"encoding/gob"
 	"errors"
+	"net"
 	"os"
 	"os/exec"
 	"os/signal"
-	"strconv"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"syscall"
 	"time"
 
+	"git.ophivana.moe/security/fortify/acl"
 	shim0 "git.ophivana.moe/security/fortify/cmd/fshim/ipc"
 	"git.ophivana.moe/security/fortify/internal"
 	"git.ophivana.moe/security/fortify/internal/fmsg"
@@ -30,14 +32,20 @@ type Shim struct {
 	aid string
 	// string representation of supplementary group ids
 	supp []string
+	// path to setup socket
+	socket string
+	// shim setup abort reason and completion
+	abort     chan error
+	abortErr  atomic.Pointer[error]
+	abortOnce sync.Once
 	// fallback exit notifier with error returned killing the process
 	killFallback chan error
 	// shim setup payload
 	payload *shim0.Payload
 }
 
-func New(uid uint32, aid string, supp []string, payload *shim0.Payload) *Shim {
+func New(uid uint32, aid string, supp []string, socket string, payload *shim0.Payload) *Shim {
-	return &Shim{uid: uid, aid: aid, supp: supp, payload: payload}
+	return &Shim{uid: uid, aid: aid, supp: supp, socket: socket, payload: payload}
 }
 
 func (s *Shim) String() string {
@@ -51,11 +59,39 @@ func (s *Shim) Unwrap() *exec.Cmd {
 	return s.cmd
 }
 
+func (s *Shim) Abort(err error) {
+	s.abortOnce.Do(func() {
+		s.abortErr.Store(&err)
+		// s.abort is buffered so this will never block
+		s.abort <- err
+	})
+}
+
+func (s *Shim) AbortWait(err error) {
+	s.Abort(err)
+	<-s.abort
+}
+
 func (s *Shim) WaitFallback() chan error {
 	return s.killFallback
 }
 
 func (s *Shim) Start() (*time.Time, error) {
+	var (
+		cf     chan *net.UnixConn
+		accept func()
+	)
+
+	// listen on setup socket
+	if c, a, err := s.serve(); err != nil {
+		return nil, fmsg.WrapErrorSuffix(err,
+			"cannot listen on shim setup socket:")
+	} else {
+		// accepts a connection after each call to accept
+		// connections are sent to the channel cf
+		cf, accept = c, a
+	}
+
 	// start user switcher process and save time
 	var fsu string
 	if p, ok := internal.Check(internal.Fsu); !ok {
@@ -65,19 +101,10 @@ func (s *Shim) Start() (*time.Time, error) {
 		fsu = p
 	}
 	s.cmd = exec.Command(fsu)
-
+	s.cmd.Env = []string{
-	var encoder *gob.Encoder
+		shim0.Env + "=" + s.socket,
-	if fd, e, err := proc.Setup(&s.cmd.ExtraFiles); err != nil {
+		"FORTIFY_APP_ID=" + s.aid,
-		return nil, fmsg.WrapErrorSuffix(err,
-			"cannot create shim setup pipe:")
-	} else {
-		encoder = e
-		s.cmd.Env = []string{
-			shim0.Env + "=" + strconv.Itoa(fd),
-			"FORTIFY_APP_ID=" + s.aid,
-		}
 	}
-
 	if len(s.supp) > 0 {
 		fmsg.VPrintf("attaching supplementary group ids %s", s.supp)
 		s.cmd.Env = append(s.cmd.Env, "FORTIFY_GROUPS="+strings.Join(s.supp, " "))
@@ -118,20 +145,117 @@ func (s *Shim) Start() (*time.Time, error) {
 		signal.Ignore(syscall.SIGINT, syscall.SIGTERM)
 	}()
 
-	shimErr := make(chan error)
+	accept()
-	go func() { shimErr <- encoder.Encode(s.payload) }()
+	var conn *net.UnixConn
-
 	select {
-	case err := <-shimErr:
+	case c := <-cf:
-		if err != nil {
+		if c == nil {
-			return &startTime, fmsg.WrapErrorSuffix(err,
+			return &startTime, fmsg.WrapErrorSuffix(*s.abortErr.Load(), "cannot accept call on setup socket:")
-				"cannot transmit shim config:")
+		} else {
+			conn = c
 		}
-		killShim = func() {}
 	case <-time.After(shimSetupTimeout):
-		return &startTime, fmsg.WrapError(errors.New("timed out waiting for shim"),
+		err := fmsg.WrapError(errors.New("timed out waiting for shim"),
-			"timed out waiting for shim")
+			"timed out waiting for shim to connect")
+		s.AbortWait(err)
+		return &startTime, err
 	}
 
-	return &startTime, nil
+	// authenticate against called provided uid and shim pid
+	if cred, err := peerCred(conn); err != nil {
+		return &startTime, fmsg.WrapErrorSuffix(*s.abortErr.Load(), "cannot retrieve shim credentials:")
+	} else if cred.Uid != s.uid {
+		fmsg.Printf("process %d owned by user %d tried to connect, expecting %d",
+			cred.Pid, cred.Uid, s.uid)
+		err = errors.New("compromised fortify build")
+		s.Abort(err)
+		return &startTime, err
+	} else if cred.Pid != int32(s.cmd.Process.Pid) {
+		fmsg.Printf("process %d tried to connect to shim setup socket, expecting shim %d",
+			cred.Pid, s.cmd.Process.Pid)
+		err = errors.New("compromised target user")
+		s.Abort(err)
+		return &startTime, err
+	}
+
+	// serve payload
+	// this also closes the connection
+	err := s.payload.Serve(conn)
+	if err == nil {
+		killShim = func() {}
+	}
+	s.Abort(err) // aborting with nil indicates success
+	return &startTime, err
+}
+
+func (s *Shim) serve() (chan *net.UnixConn, func(), error) {
+	if s.abort != nil {
+		panic("attempted to serve shim setup twice")
+	}
+	s.abort = make(chan error, 1)
+
+	cf := make(chan *net.UnixConn)
+	accept := make(chan struct{}, 1)
+
+	if l, err := net.ListenUnix("unix", &net.UnixAddr{Name: s.socket, Net: "unix"}); err != nil {
+		return nil, nil, err
+	} else {
+		l.SetUnlinkOnClose(true)
+
+		fmsg.VPrintf("listening on shim setup socket %q", s.socket)
+		if err = acl.UpdatePerm(s.socket, int(s.uid), acl.Read, acl.Write, acl.Execute); err != nil {
+			fmsg.Println("cannot append ACL entry to shim setup socket:", err)
+			s.Abort(err) // ensures setup socket cleanup
+		}
+
+		go func() {
+			cfWg := new(sync.WaitGroup)
+			for {
+				select {
+				case err = <-s.abort:
+					if err != nil {
+						fmsg.VPrintln("aborting shim setup, reason:", err)
+					}
+					if err = l.Close(); err != nil {
+						fmsg.Println("cannot close setup socket:", err)
+					}
+					close(s.abort)
+					go func() {
+						cfWg.Wait()
+						close(cf)
+					}()
+					return
+				case <-accept:
+					cfWg.Add(1)
+					go func() {
+						defer cfWg.Done()
+						if conn, err0 := l.AcceptUnix(); err0 != nil {
+							// breaks loop
+							s.Abort(err0)
+							// receiver sees nil value and loads err0 stored during abort
+							cf <- nil
+						} else {
+							cf <- conn
+						}
+					}()
+				}
+			}
+		}()
+	}
+
+	return cf, func() { accept <- struct{}{} }, nil
+}
+
+// peerCred fetches peer credentials of conn
+func peerCred(conn *net.UnixConn) (ucred *syscall.Ucred, err error) {
+	var raw syscall.RawConn
+	if raw, err = conn.SyscallConn(); err != nil {
+		return
+	}
+
+	err0 := raw.Control(func(fd uintptr) {
+		ucred, err = syscall.GetsockoptUcred(int(fd), syscall.SOL_SOCKET, syscall.SO_PEERCRED)
+	})
+	err = errors.Join(err, err0)
+	return
 }

cmd/fshim/main.go

@@ -1,7 +1,8 @@
 package main
 
 import (
-	"errors"
+	"encoding/gob"
+	"net"
 	"os"
 	"path"
 	"strconv"
@@ -12,7 +13,6 @@ import (
 	"git.ophivana.moe/security/fortify/helper"
 	"git.ophivana.moe/security/fortify/internal"
 	"git.ophivana.moe/security/fortify/internal/fmsg"
-	"git.ophivana.moe/security/fortify/internal/proc"
 )
 
 // everything beyond this point runs as unconstrained target user
@@ -37,6 +37,15 @@ func main() {
 		}
 	}
 
+	// lookup socket path from environment
+	var socketPath string
+	if s, ok := os.LookupEnv(shim.Env); !ok {
+		fmsg.Fatal("FORTIFY_SHIM not set")
+		panic("unreachable")
+	} else {
+		socketPath = s
+	}
+
 	// check path to finit
 	var finitPath string
 	if p, ok := internal.Path(internal.Finit); !ok {
@@ -45,24 +54,21 @@ func main() {
 		finitPath = p
 	}
 
-	// receive setup payload
+	// dial setup socket
-	var (
+	var conn *net.UnixConn
-		payload    shim.Payload
+	if c, err := net.DialUnix("unix", nil, &net.UnixAddr{Name: socketPath, Net: "unix"}); err != nil {
-		closeSetup func() error
+		fmsg.Fatal(err.Error())
-	)
-	if f, err := proc.Receive(shim.Env, &payload); err != nil {
-		if errors.Is(err, proc.ErrInvalid) {
-			fmsg.Fatal("invalid config descriptor")
-		}
-		if errors.Is(err, proc.ErrNotSet) {
-			fmsg.Fatal("FORTIFY_SHIM not set")
-		}
-
-		fmsg.Fatalf("cannot decode shim setup payload: %v", err)
 		panic("unreachable")
+	} else {
+		conn = c
+	}
+
+	// decode payload gob stream
+	var payload shim.Payload
+	if err := gob.NewDecoder(conn).Decode(&payload); err != nil {
+		fmsg.Fatalf("cannot decode shim payload: %v", err)
 	} else {
 		fmsg.SetVerbose(payload.Verbose)
-		closeSetup = f
 	}
 
 	if payload.Bwrap == nil {
@@ -75,8 +81,8 @@ func main() {
 	}
 
 	// close setup socket
-	if err := closeSetup(); err != nil {
+	if err := conn.Close(); err != nil {
-		fmsg.Println("cannot close setup pipe:", err)
+		fmsg.Println("cannot close setup socket:", err)
 		// not fatal
 	}
 
@@ -104,14 +110,17 @@ func main() {
 
 	var extraFiles []*os.File
 
-	// serve setup payload
+	// share config pipe
-	if fd, encoder, err := proc.Setup(&extraFiles); err != nil {
+	if r, w, err := os.Pipe(); err != nil {
 		fmsg.Fatalf("cannot pipe: %v", err)
 	} else {
-		conf.SetEnv[init0.Env] = strconv.Itoa(fd)
+		conf.SetEnv[init0.Env] = strconv.Itoa(3 + len(extraFiles))
+		extraFiles = append(extraFiles, r)
+
+		fmsg.VPrintln("transmitting config to init")
 		go func() {
-			fmsg.VPrintln("transmitting config to init")
+			// stream config to pipe
-			if err = encoder.Encode(&ic); err != nil {
+			if err = gob.NewEncoder(w).Encode(&ic); err != nil {
 				fmsg.Fatalf("cannot transmit init config: %v", err)
 			}
 		}()

cmd/fsu/main.go

@@ -83,17 +83,17 @@ func main() {
 		uid += aid
 	}
 
-	// pass through setup fd to shim
+	// pass through setup path to shim
-	var shimSetupFd string
+	var shimSetupPath string
 	if s, ok := os.LookupEnv(envShim); !ok {
 		// fortify requests target uid
 		// print resolved uid and exit
 		fmt.Print(uid)
 		os.Exit(0)
-	} else if len(s) != 1 || s[0] > '9' || s[0] < '3' {
+	} else if !path.IsAbs(s) {
-		log.Fatal("FORTIFY_SHIM holds an invalid value")
+		log.Fatal("FORTIFY_SHIM is not absolute")
 	} else {
-		shimSetupFd = s
+		shimSetupPath = s
 	}
 
 	// supplementary groups
@@ -142,7 +142,7 @@ func main() {
 	if _, _, errno := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, PR_SET_NO_NEW_PRIVS, 1, 0); errno != 0 {
 		log.Fatalf("cannot set no_new_privs flag: %s", errno.Error())
 	}
-	if err := syscall.Exec(fshim, []string{"fshim"}, []string{envShim + "=" + shimSetupFd}); err != nil {
+	if err := syscall.Exec(fshim, []string{"fshim"}, []string{envShim + "=" + shimSetupPath}); err != nil {
 		log.Fatalf("cannot start shim: %v", err)
 	}
 

fipc/config.go

@@ -1,4 +1,4 @@
-package fst
+package fipc
 
 import (
 	"errors"

internal/app/app.go

@@ -5,13 +5,13 @@ import (
 	"sync/atomic"
 
 	"git.ophivana.moe/security/fortify/cmd/fshim/ipc/shim"
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/internal/linux"
 )
 
 type App interface {
 	// ID returns a copy of App's unique ID.
-	ID() fst.ID
+	ID() ID
 	// Start sets up the system and starts the App.
 	Start() error
 	// Wait waits for App's process to exit and reverts system setup.
@@ -19,7 +19,7 @@ type App interface {
 	// WaitErr returns error returned by the underlying wait syscall.
 	WaitErr() error
 
-	Seal(config *fst.Config) error
+	Seal(config *fipc.Config) error
 	String() string
 }
 
@@ -28,7 +28,7 @@ type app struct {
 	ct *appCt
 
 	// application unique identifier
-	id *fst.ID
+	id *ID
 	// operating system interface
 	os linux.System
 	// shim process manager
@@ -41,7 +41,7 @@ type app struct {
 	lock sync.RWMutex
 }
 
-func (a *app) ID() fst.ID {
+func (a *app) ID() ID {
 	return *a.id
 }
 
@@ -70,18 +70,18 @@ func (a *app) WaitErr() error {
 
 func New(os linux.System) (App, error) {
 	a := new(app)
-	a.id = new(fst.ID)
+	a.id = new(ID)
 	a.os = os
-	return a, fst.NewAppID(a.id)
+	return a, newAppID(a.id)
 }
 
 // appCt ensures its wrapped val is only accessed once
 type appCt struct {
-	val  *fst.Config
+	val  *fipc.Config
 	done *atomic.Bool
 }
 
-func (a *appCt) Unwrap() *fst.Config {
+func (a *appCt) Unwrap() *fipc.Config {
 	if !a.done.Load() {
 		defer a.done.Store(true)
 		return a.val
@@ -89,7 +89,7 @@ func (a *appCt) Unwrap() *fst.Config {
 	panic("attempted to access config reference twice")
 }
 
-func newAppCt(config *fst.Config) (ct *appCt) {
+func newAppCt(config *fipc.Config) (ct *appCt) {
 	ct = new(appCt)
 	ct.done = new(atomic.Bool)
 	ct.val = config

internal/app/app_nixos_test.go

@@ -3,23 +3,24 @@ package app_test
 import (
 	"git.ophivana.moe/security/fortify/acl"
 	"git.ophivana.moe/security/fortify/dbus"
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/helper/bwrap"
+	"git.ophivana.moe/security/fortify/internal/app"
 	"git.ophivana.moe/security/fortify/internal/system"
 )
 
 var testCasesNixos = []sealTestCase{
 	{
 		"nixos chromium direct wayland", new(stubNixOS),
-		&fst.Config{
+		&fipc.Config{
 			ID:      "org.chromium.Chromium",
 			Command: []string{"/nix/store/yqivzpzzn7z5x0lq9hmbzygh45d8rhqd-chromium-start"},
-			Confinement: fst.ConfinementConfig{
+			Confinement: fipc.ConfinementConfig{
 				AppID: 1, Groups: []string{}, Username: "u0_a1",
 				Outer: "/var/lib/persist/module/fortify/0/1",
-				Sandbox: &fst.SandboxConfig{
+				Sandbox: &fipc.SandboxConfig{
 					UserNS: true, Net: true, MapRealUID: true, DirectWayland: true, Env: nil,
-					Filesystem: []*fst.FilesystemConfig{
+					Filesystem: []*fipc.FilesystemConfig{
 						{Src: "/bin", Must: true}, {Src: "/usr/bin", Must: true},
 						{Src: "/nix/store", Must: true}, {Src: "/run/current-system", Must: true},
 						{Src: "/sys/block"}, {Src: "/sys/bus"}, {Src: "/sys/class"}, {Src: "/sys/dev"}, {Src: "/sys/devices"},
@@ -48,7 +49,7 @@ var testCasesNixos = []sealTestCase{
 				Enablements: system.EWayland.Mask() | system.EDBus.Mask() | system.EPulse.Mask(),
 			},
 		},
-		fst.ID{
+		app.ID{
 			0x8e, 0x2c, 0x76, 0xb0,
 			0x66, 0xda, 0xbe, 0x57,
 			0x4c, 0xf0, 0x73, 0xbd,

internal/app/app_pd_test.go

@@ -3,23 +3,24 @@ package app_test
 import (
 	"git.ophivana.moe/security/fortify/acl"
 	"git.ophivana.moe/security/fortify/dbus"
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/helper/bwrap"
+	"git.ophivana.moe/security/fortify/internal/app"
 	"git.ophivana.moe/security/fortify/internal/system"
 )
 
 var testCasesPd = []sealTestCase{
 	{
 		"nixos permissive defaults no enablements", new(stubNixOS),
-		&fst.Config{
+		&fipc.Config{
 			Command: make([]string, 0),
-			Confinement: fst.ConfinementConfig{
+			Confinement: fipc.ConfinementConfig{
 				AppID:    0,
 				Username: "chronos",
 				Outer:    "/home/chronos",
 			},
 		},
-		fst.ID{
+		app.ID{
 			0x4a, 0x45, 0x0b, 0x65,
 			0x96, 0xd7, 0xbc, 0x15,
 			0xbd, 0x01, 0x78, 0x0e,
@@ -190,10 +191,10 @@ var testCasesPd = []sealTestCase{
 	},
 	{
 		"nixos permissive defaults chromium", new(stubNixOS),
-		&fst.Config{
+		&fipc.Config{
 			ID:      "org.chromium.Chromium",
 			Command: []string{"/run/current-system/sw/bin/zsh", "-c", "exec chromium "},
-			Confinement: fst.ConfinementConfig{
+			Confinement: fipc.ConfinementConfig{
 				AppID:    9,
 				Groups:   []string{"video"},
 				Username: "chronos",
@@ -232,7 +233,7 @@ var testCasesPd = []sealTestCase{
 				Enablements: system.EWayland.Mask() | system.EDBus.Mask() | system.EPulse.Mask(),
 			},
 		},
-		fst.ID{
+		app.ID{
 			0xeb, 0xf0, 0x83, 0xd1,
 			0xb1, 0x75, 0x91, 0x17,
 			0x82, 0xd4, 0x13, 0x36,

internal/app/app_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/helper/bwrap"
 	"git.ophivana.moe/security/fortify/internal/app"
 	"git.ophivana.moe/security/fortify/internal/linux"
@@ -16,8 +16,8 @@ import (
 type sealTestCase struct {
 	name      string
 	os        linux.System
-	config    *fst.Config
+	config    *fipc.Config
-	id        fst.ID
+	id        app.ID
 	wantSys   *system.I
 	wantBwrap *bwrap.Config
 }

internal/app/export_test.go

@@ -1,13 +1,12 @@
 package app
 
 import (
-	"git.ophivana.moe/security/fortify/fst"
 	"git.ophivana.moe/security/fortify/helper/bwrap"
 	"git.ophivana.moe/security/fortify/internal/linux"
 	"git.ophivana.moe/security/fortify/internal/system"
 )
 
-func NewWithID(id fst.ID, os linux.System) App {
+func NewWithID(id ID, os linux.System) App {
 	a := new(app)
 	a.id = &id
 	a.os = os

internal/app/id.go

@@ -1,5 +1,4 @@
-// Package fst exports shared fortify types.
+package app
-package fst
 
 import (
 	"crypto/rand"
@@ -12,7 +11,7 @@ func (a *ID) String() string {
 	return hex.EncodeToString(a[:])
 }
 
-func NewAppID(id *ID) error {
+func newAppID(id *ID) error {
 	_, err := rand.Read(id[:])
 	return err
 }

internal/app/seal.go

@@ -9,7 +9,7 @@ import (
 	"strconv"
 
 	"git.ophivana.moe/security/fortify/dbus"
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/internal/fmsg"
 	"git.ophivana.moe/security/fortify/internal/linux"
 	"git.ophivana.moe/security/fortify/internal/state"
@@ -60,7 +60,7 @@ type appSeal struct {
 }
 
 // Seal seals the app launch context
-func (a *app) Seal(config *fst.Config) error {
+func (a *app) Seal(config *fipc.Config) error {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
@@ -148,7 +148,7 @@ func (a *app) Seal(config *fst.Config) error {
 		fmsg.VPrintln("sandbox configuration not supplied, PROCEED WITH CAUTION")
 
 		// permissive defaults
-		conf := &fst.SandboxConfig{
+		conf := &fipc.SandboxConfig{
 			UserNS:       true,
 			Net:          true,
 			NoNewSession: true,
@@ -158,7 +158,7 @@ func (a *app) Seal(config *fst.Config) error {
 		if d, err := a.os.ReadDir("/"); err != nil {
 			return err
 		} else {
-			b := make([]*fst.FilesystemConfig, 0, len(d))
+			b := make([]*fipc.FilesystemConfig, 0, len(d))
 			for _, ent := range d {
 				p := "/" + ent.Name()
 				switch p {
@@ -170,7 +170,7 @@ func (a *app) Seal(config *fst.Config) error {
 				case "/etc":
 
 				default:
-					b = append(b, &fst.FilesystemConfig{Src: p, Write: true, Must: true})
+					b = append(b, &fipc.FilesystemConfig{Src: p, Write: true, Must: true})
 				}
 			}
 			conf.Filesystem = append(conf.Filesystem, b...)
@@ -179,7 +179,7 @@ func (a *app) Seal(config *fst.Config) error {
 		if d, err := a.os.ReadDir("/run"); err != nil {
 			return err
 		} else {
-			b := make([]*fst.FilesystemConfig, 0, len(d))
+			b := make([]*fipc.FilesystemConfig, 0, len(d))
 			for _, ent := range d {
 				name := ent.Name()
 				switch name {
@@ -187,7 +187,7 @@ func (a *app) Seal(config *fst.Config) error {
 				case "dbus":
 				default:
 					p := "/run/" + name
-					b = append(b, &fst.FilesystemConfig{Src: p, Write: true, Must: true})
+					b = append(b, &fipc.FilesystemConfig{Src: p, Write: true, Must: true})
 				}
 			}
 			conf.Filesystem = append(conf.Filesystem, b...)
@@ -199,7 +199,7 @@ func (a *app) Seal(config *fst.Config) error {
 		}
 		// bind GPU stuff
 		if config.Confinement.Enablements.Has(system.EX11) || config.Confinement.Enablements.Has(system.EWayland) {
-			conf.Filesystem = append(conf.Filesystem, &fst.FilesystemConfig{Src: "/dev/dri", Device: true})
+			conf.Filesystem = append(conf.Filesystem, &fipc.FilesystemConfig{Src: "/dev/dri", Device: true})
 		}
 
 		config.Confinement.Sandbox = conf

internal/app/start.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"strings"
 
@@ -45,6 +46,7 @@ func (a *app) Start() error {
 		uint32(a.seal.sys.UID()),
 		a.seal.sys.user.as,
 		a.seal.sys.user.supp,
+		path.Join(a.seal.share, "shim"),
 		&shim0.Payload{
 			Argv:  a.seal.command,
 			Exec:  shimExec,
@@ -250,6 +252,12 @@ func (a *app) Wait() (int, error) {
 				}
 			}
 
+			if a.shim.Unwrap() == nil {
+				fmsg.VPrintln("fault before shim start")
+			} else {
+				a.shim.AbortWait(errors.New("shim exited"))
+			}
+
 			if a.seal.sys.needRevert {
 				if err := a.seal.sys.Revert(ec); err != nil {
 					return err.(RevertCompoundError)

internal/proc/fd.go

@@ -1,42 +0,0 @@
-package proc
-
-import (
-	"encoding/gob"
-	"errors"
-	"os"
-	"strconv"
-)
-
-var (
-	ErrNotSet  = errors.New("environment variable not set")
-	ErrInvalid = errors.New("bad file descriptor")
-)
-
-func Setup(extraFiles *[]*os.File) (int, *gob.Encoder, error) {
-	if r, w, err := os.Pipe(); err != nil {
-		return -1, nil, err
-	} else {
-		fd := 3 + len(*extraFiles)
-		*extraFiles = append(*extraFiles, r)
-		return fd, gob.NewEncoder(w), nil
-	}
-}
-
-func Receive(key string, e any) (func() error, error) {
-	var setup *os.File
-
-	if s, ok := os.LookupEnv(key); !ok {
-		return nil, ErrNotSet
-	} else {
-		if fd, err := strconv.Atoi(s); err != nil {
-			return nil, err
-		} else {
-			setup = os.NewFile(uintptr(fd), "setup")
-			if setup == nil {
-				return nil, ErrInvalid
-			}
-		}
-	}
-
-	return func() error { return setup.Close() }, gob.NewDecoder(setup).Decode(e)
-}

internal/state/state.go

@@ -3,7 +3,7 @@ package state
 import (
 	"time"
 
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 )
 
 type Store interface {
@@ -27,11 +27,11 @@ type Backend interface {
 // State is the on-disk format for a fortified process's state information
 type State struct {
 	// fortify instance id
-	ID fst.ID `json:"instance"`
+	ID [16]byte `json:"instance"`
 	// child process PID value
 	PID int `json:"pid"`
 	// sealed app configuration
-	Config *fst.Config `json:"config"`
+	Config *fipc.Config `json:"config"`
 
 	// process start time
 	Time time.Time

main.go

@@ -12,7 +12,7 @@ import (
 	"text/tabwriter"
 
 	"git.ophivana.moe/security/fortify/dbus"
-	"git.ophivana.moe/security/fortify/fst"
+	"git.ophivana.moe/security/fortify/fipc"
 	"git.ophivana.moe/security/fortify/internal"
 	"git.ophivana.moe/security/fortify/internal/app"
 	"git.ophivana.moe/security/fortify/internal/fmsg"
@@ -103,7 +103,7 @@ func main() {
 		fmt.Println(license)
 		fmsg.Exit(0)
 	case "template": // print full template configuration
-		if s, err := json.MarshalIndent(fst.Template(), "", "  "); err != nil {
+		if s, err := json.MarshalIndent(fipc.Template(), "", "  "); err != nil {
 			fmsg.Fatalf("cannot generate template: %v", err)
 			panic("unreachable")
 		} else {
@@ -130,7 +130,7 @@ func main() {
 			fmsg.Fatal("app requires at least 1 argument")
 		}
 
-		config := new(fst.Config)
+		config := new(fipc.Config)
 		if f, err := os.Open(args[1]); err != nil {
 			fmsg.Fatalf("cannot access config file %q: %s", args[1], err)
 			panic("unreachable")
@@ -180,7 +180,7 @@ func main() {
 		_ = set.Parse(args[1:])
 
 		// initialise config from flags
-		config := &fst.Config{
+		config := &fipc.Config{
 			ID:      fid,
 			Command: set.Args(),
 		}
@@ -276,7 +276,7 @@ func main() {
 	panic("unreachable")
 }
 
-func runApp(config *fst.Config) {
+func runApp(config *fipc.Config) {
 	if os.SdBooted() {
 		fmsg.VPrintln("system booted with systemd as init system")
 	}