--- a/proxy/tun/tun_darwin.go
+++ b/proxy/tun/tun_darwin.go
@@ -41,10 +41,10 @@
 )
 
 type DarwinTun struct {
-	tunFile *os.File
-	options *Config
-	tunFd   int
-	ownsFd  bool // true for macOS (we created the fd), false for iOS (fd from system)
+	tunFile          *os.File
+	options          *Config
+	tunFd            int
+	managesInterface bool // macOS configures its interface; iOS uses NetworkExtension settings.
 
 	// Genuinely blocks Wait() until tunFd is readable, instead of the
 	// previous procyield-only busy-spin (dispatchLoop in
@@ -154,22 +154,30 @@
 	// Check if fd is provided via environment (iOS mode)
 	fdStr := platform.NewEnvFlag(platform.TunFdKey).GetValue(func() string { return "" })
 	if fdStr != "" {
-		// iOS: use provided fd from NetworkExtension
+		// iOS: borrow the NetworkExtension fd, but own a distinct duplicate.
+		// os.NewFile installs a closing finalizer; wrapping the caller's fd
+		// directly can close an unrelated socket after that fd is reused.
 		fd, err := strconv.Atoi(fdStr)
 		if err != nil {
 			return nil, err
 		}
 
+		fd, err = unix.Dup(fd)
+		if err != nil {
+			return nil, err
+		}
+		unix.CloseOnExec(fd)
 		if err = unix.SetNonblock(fd, true); err != nil {
+			_ = unix.Close(fd)
 			return nil, err
 		}
 
 		return &DarwinTun{
-			tunFile: os.NewFile(uintptr(fd), "utun"),
-			options: options,
-			tunFd:   fd,
-			ownsFd:  false,
-			waitKq:  newWaitKqueue(fd),
+			tunFile:          os.NewFile(uintptr(fd), "utun"),
+			options:          options,
+			tunFd:            fd,
+			managesInterface: false,
+			waitKq:           newWaitKqueue(fd),
 		}, nil
 	}
 
@@ -192,17 +200,17 @@
 	}
 
 	return &DarwinTun{
-		tunFile: tunFile,
-		options: options,
-		tunFd:   int(tunFile.Fd()),
-		ownsFd:  true,
-		waitKq:  newWaitKqueue(int(tunFile.Fd())),
-		gateway: gateway,
+		tunFile:          tunFile,
+		options:          options,
+		tunFd:            int(tunFile.Fd()),
+		managesInterface: true,
+		waitKq:           newWaitKqueue(int(tunFile.Fd())),
+		gateway:          gateway,
 	}, nil
 }
 
 func (t *DarwinTun) Start() error {
-	if !t.ownsFd {
+	if !t.managesInterface {
 		return nil
 	}
 
@@ -232,11 +240,10 @@
 		t.waitKq.close()
 	}
 	routeErr := t.unsetSystemRoutes()
-	if t.ownsFd {
-		return xerrors.Combine(routeErr, t.tunFile.Close())
-	}
-	// iOS: don't close the fd, it's owned by NetworkExtension
-	return routeErr
+	// Both platforms own tunFile. On iOS it wraps our duplicate, never the
+	// caller's descriptor. Close through os.File to disarm its finalizer and
+	// wake pending reads before the descriptor number can be reused.
+	return xerrors.Combine(routeErr, t.tunFile.Close())
 }
 
 func (t *DarwinTun) monitorRouteChanges() {
--- /dev/null
+++ b/proxy/tun/tivra_darwin_fd_test.go
@@ -0,0 +1,97 @@
+//go:build darwin
+
+package tun
+
+import (
+	"errors"
+	"runtime"
+	"runtime/debug"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/xtls/xray-core/common/platform"
+	"golang.org/x/sys/unix"
+)
+
+func newBorrowedDarwinTun(t *testing.T, fd int) *DarwinTun {
+	t.Helper()
+	t.Setenv(platform.TunFdKey, strconv.Itoa(fd))
+	device, err := NewTun(&Config{MTU: 1280})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return device.(*DarwinTun)
+}
+
+func requireFDOpen(t *testing.T, fd int) {
+	t.Helper()
+	if _, err := unix.FcntlInt(uintptr(fd), unix.F_GETFD, 0); err != nil {
+		t.Fatalf("descriptor %d unexpectedly closed: %v", fd, err)
+	}
+}
+
+func TestTivraDarwinTunOwnsDuplicateAndPreservesBorrowedFD(t *testing.T) {
+	borrowed, peer := newTestSocketpair(t)
+	device := newBorrowedDarwinTun(t, borrowed)
+	t.Cleanup(func() { _ = device.Close() })
+	if device.tunFd == borrowed {
+		t.Fatal("core must own a duplicate, not wrap the caller's descriptor")
+	}
+	if device.managesInterface {
+		t.Fatal("iOS descriptor must not enable macOS interface/route configuration")
+	}
+	if err := device.Start(); err != nil {
+		t.Fatalf("borrowed mode must not configure system routes: %v", err)
+	}
+	owned := device.tunFd
+	if err := device.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := unix.FcntlInt(uintptr(owned), unix.F_GETFD, 0); !errors.Is(err, unix.EBADF) {
+		t.Fatalf("owned duplicate was not closed: %v", err)
+	}
+	requireFDOpen(t, borrowed)
+	if _, err := unix.Write(peer, []byte{1}); err != nil {
+		t.Fatal(err)
+	}
+	packet := make([]byte, 1)
+	if n, err := unix.Read(borrowed, packet); err != nil || n != 1 || packet[0] != 1 {
+		t.Fatalf("caller descriptor stopped working after core close: n=%d error=%v", n, err)
+	}
+}
+
+func TestTivraDarwinTunStopReuseAndGCDoNotCloseNewSocket(t *testing.T) {
+	borrowed, peer := newTestSocketpair(t)
+	for cycle := 0; cycle < 20; cycle++ {
+		device := newBorrowedDarwinTun(t, borrowed)
+		owned := device.tunFd
+		if err := device.Close(); err != nil {
+			t.Fatal(err)
+		}
+		// Reuse exactly the core's old descriptor number. A stale os.File
+		// finalizer would close this new socket during the forced collections.
+		if err := unix.Dup2(peer, owned); err != nil {
+			t.Fatal(err)
+		}
+		device = nil
+		for i := 0; i < 3; i++ {
+			runtime.GC()
+			debug.FreeOSMemory()
+			time.Sleep(5 * time.Millisecond)
+		}
+		requireFDOpen(t, owned)
+		requireFDOpen(t, borrowed)
+		if err := unix.Close(owned); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestTivraDarwinTunRejectsClosedBorrowedFD(t *testing.T) {
+	t.Setenv(platform.TunFdKey, "-1")
+	if device, err := NewTun(&Config{MTU: 1280}); err == nil {
+		_ = device.Close()
+		t.Fatal("invalid caller descriptor must fail before creating a TUN")
+	}
+}
