@holoscript/holosystem 0.2.4 → 0.2.5

package/native/windows-sandbox/Program.cs

@@ -1,13 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Net;
+using System.Net.Sockets;
 using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Principal;
 using System.Text;
 using System.Threading.Tasks;
 
 internal static class Program
 {
     private const string Protocol = "holoscript.holosystem.windows-sandbox-launch.v1";
+    private const string AppContainerProtocol = "holoscript.holosystem.windows-appcontainer-launch.v1";
     private const string LowIntegritySid = "S-1-16-4096";
     private const int OutputLimit = 1024 * 1024;
 
@@ -21,6 +27,9 @@ internal static class Program
     private const uint SePrivilegeEnabled = 0x2;
     private const int TokenPrivileges = 3;
     private const int TokenIntegrityLevel = 25;
+    private const int TokenIsAppContainer = 29;
+    private const int TokenCapabilities = 30;
+    private const int TokenAppContainerSid = 31;
 
     private const uint CreateSuspended = 0x00000004;
     private const uint CreateNoWindow = 0x08000000;
@@ -49,6 +58,11 @@ internal static class Program
     private const uint JobObjectUiLimitExitWindows = 0x00000080;
     private const int JobObjectBasicUiRestrictions = 4;
     private const int JobObjectExtendedLimitInformation = 9;
+    private const int ErrorAccessDenied = 5;
+    private const int WsaAccessDenied = 10013;
+    private const int WsaTimedOut = 10060;
+    private static readonly IntPtr ProcThreadAttributeHandleList = new IntPtr(0x00020002);
+    private static readonly IntPtr ProcThreadAttributeSecurityCapabilities = new IntPtr(0x00020009);
 
     private sealed class Arguments
     {
@@ -59,6 +73,9 @@ internal static class Program
         public int TimeoutMilliseconds;
         public UIntPtr ProcessMemoryBytes;
         public string[] ChildArguments;
+        public bool AppContainerDeny;
+        public string ProtectedSentinel;
+        public string CanaryExecutable;
     }
 
     private sealed class LaunchResult
@@ -78,6 +95,18 @@ internal static class Program
         public bool ProcessMemoryLimit;
         public bool UiRestrictions;
         public bool WritableTempLowIntegrity;
+        public bool AppContainer;
+        public bool AppContainerSidMatched;
+        public int CapabilityCount;
+        public bool SnapshotReadExecuteGrant;
+        public bool WritableTempModifyGrant;
+        public bool FilesystemCanaryDenied;
+        public int FilesystemCanaryError;
+        public bool NetworkCanaryDenied;
+        public int NetworkCanaryError;
+        public bool LoopbackAccepted;
+        public bool ProfileDeleted;
+        public bool AppContainerMode;
         public byte[] StandardOutput = new byte[0];
         public byte[] StandardError = new byte[0];
         public string ErrorStage;
@@ -126,7 +155,11 @@ internal static class Program
             "--executable", "--working-directory", "--sandbox-root", "--writable-temp",
             "--timeout-ms", "--process-memory-bytes"
         };
-        if (values.Count != required.Length)
+        bool appContainerDeny = values.ContainsKey("--appcontainer-deny") ||
+            values.ContainsKey("--protected-sentinel") ||
+            values.ContainsKey("--canary-executable");
+        int expectedCount = required.Length + (appContainerDeny ? 3 : 0);
+        if (values.Count != expectedCount)
         {
             throw new ArgumentException("Unknown or missing launcher field.");
         }
@@ -134,6 +167,14 @@ internal static class Program
         {
             if (!values.ContainsKey(key)) throw new ArgumentException("Missing launcher field " + key + ".");
         }
+        if (appContainerDeny &&
+            (!values.ContainsKey("--appcontainer-deny") ||
+             !values.ContainsKey("--protected-sentinel") ||
+             !values.ContainsKey("--canary-executable") ||
+             values["--appcontainer-deny"] != "v1"))
+        {
+            throw new ArgumentException("AppContainer deny mode requires its exact closed fields.");
+        }
 
         int timeout;
         ulong memory;
@@ -158,6 +199,22 @@ internal static class Program
         {
             throw new ArgumentException("Executable, working directory, and writable temp must stay inside sandbox-root.");
         }
+        string protectedSentinel = appContainerDeny
+            ? Path.GetFullPath(values["--protected-sentinel"])
+            : null;
+        if (appContainerDeny &&
+            (IsInsideRoot(protectedSentinel, root, rootPrefix) || !File.Exists(protectedSentinel)))
+        {
+            throw new ArgumentException("Protected sentinel must be an existing caller-readable file outside sandbox-root.");
+        }
+        string canaryExecutable = appContainerDeny
+            ? Path.GetFullPath(values["--canary-executable"])
+            : null;
+        if (appContainerDeny &&
+            (!IsInsideRoot(canaryExecutable, root, rootPrefix) || !File.Exists(canaryExecutable)))
+        {
+            throw new ArgumentException("AppContainer canary must be an existing file inside sandbox-root.");
+        }
 
         string[] child = new string[args.Length - separator - 1];
         Array.Copy(args, separator + 1, child, 0, child.Length);
@@ -169,6 +226,9 @@ internal static class Program
             TimeoutMilliseconds = timeout,
             ProcessMemoryBytes = new UIntPtr(memory),
             ChildArguments = child,
+            AppContainerDeny = appContainerDeny,
+            ProtectedSentinel = protectedSentinel,
+            CanaryExecutable = canaryExecutable,
         };
     }
 
@@ -184,6 +244,8 @@ internal static class Program
         IntPtr processToken = IntPtr.Zero;
         IntPtr restrictedToken = IntPtr.Zero;
         IntPtr lowSid = IntPtr.Zero;
+        IntPtr appContainerSid = IntPtr.Zero;
+        IntPtr childToken = IntPtr.Zero;
         IntPtr job = IntPtr.Zero;
         IntPtr stdoutRead = IntPtr.Zero;
         IntPtr stdoutWrite = IntPtr.Zero;
@@ -192,12 +254,16 @@ internal static class Program
         IntPtr nullInput = IntPtr.Zero;
         IntPtr attributeList = IntPtr.Zero;
         IntPtr handleList = IntPtr.Zero;
+        IntPtr securityCapabilitiesPointer = IntPtr.Zero;
+        string appContainerIdentity = null;
+        bool appContainerProfileCreated = false;
         PROCESS_INFORMATION process = new PROCESS_INFORMATION();
 
         try
         {
             ApplyLowIntegrityLabel(args.WritableTemp);
             result.WritableTempLowIntegrity = true;
+            result.AppContainerMode = args.AppContainerDeny;
 
             uint tokenAccess = TokenAssignPrimary | TokenDuplicate | TokenQuery | TokenAdjustDefault | TokenAdjustSessionId;
             Check(OpenProcessToken(GetCurrentProcess(), tokenAccess, out processToken), "open-process-token");
@@ -223,6 +289,35 @@ internal static class Program
             result.ProcessMemoryLimit = true;
             result.UiRestrictions = true;
 
+            if (args.AppContainerDeny)
+            {
+                appContainerIdentity = "HoloScript.HoloSystem.WHPX_" + Guid.NewGuid().ToString("N");
+                int profileResult = CreateAppContainerProfile(
+                    appContainerIdentity,
+                    "HoloSystem WHPX isolation",
+                    "Ephemeral zero-capability HoloSystem VM host boundary",
+                    IntPtr.Zero,
+                    0,
+                    out appContainerSid
+                );
+                if (profileResult != 0)
+                {
+                    throw new LauncherException("create-appcontainer-profile", profileResult);
+                }
+                appContainerProfileCreated = true;
+                SecurityIdentifier appSid = new SecurityIdentifier(appContainerSid);
+                GrantDirectoryAccess(args.SandboxRoot, appSid, FileSystemRights.ReadAndExecute | FileSystemRights.ListDirectory);
+                result.SnapshotReadExecuteGrant = true;
+                GrantDirectoryAccess(args.WritableTemp, appSid, FileSystemRights.Modify);
+                result.WritableTempModifyGrant = true;
+                HardenProtectedSentinel(args.ProtectedSentinel);
+                RunAppContainerCanaries(args, restrictedToken, appContainerSid, job, result);
+                if (!result.FilesystemCanaryDenied || !result.NetworkCanaryDenied)
+                {
+                    throw new LauncherException("appcontainer-canary-denial", 0);
+                }
+            }
+
             SECURITY_ATTRIBUTES pipeSecurity = new SECURITY_ATTRIBUTES();
             pipeSecurity.nLength = Marshal.SizeOf(typeof(SECURITY_ATTRIBUTES));
             pipeSecurity.bInheritHandle = true;
@@ -235,9 +330,10 @@ internal static class Program
             Check(nullInput != new IntPtr(-1), "open-null-input");
 
             UIntPtr attributeBytes = UIntPtr.Zero;
-            InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref attributeBytes);
+            int attributeCount = args.AppContainerDeny ? 2 : 1;
+            InitializeProcThreadAttributeList(IntPtr.Zero, attributeCount, 0, ref attributeBytes);
             attributeList = Marshal.AllocHGlobal((int)attributeBytes.ToUInt64());
-            Check(InitializeProcThreadAttributeList(attributeList, 1, 0, ref attributeBytes), "initialize-handle-allowlist");
+            Check(InitializeProcThreadAttributeList(attributeList, attributeCount, 0, ref attributeBytes), "initialize-handle-allowlist");
             handleList = Marshal.AllocHGlobal(IntPtr.Size * 3);
             Marshal.WriteIntPtr(handleList, 0, nullInput);
             Marshal.WriteIntPtr(handleList, IntPtr.Size, stdoutWrite);
@@ -245,7 +341,7 @@ internal static class Program
             Check(UpdateProcThreadAttribute(
                 attributeList,
                 0,
-                new IntPtr(0x00020002),
+                ProcThreadAttributeHandleList,
                 handleList,
                 new UIntPtr((uint)(IntPtr.Size * 3)),
                 IntPtr.Zero,
@@ -253,6 +349,27 @@ internal static class Program
             ), "set-handle-allowlist");
             result.HandleAllowlist = true;
 
+            if (args.AppContainerDeny)
+            {
+                SECURITY_CAPABILITIES securityCapabilities = new SECURITY_CAPABILITIES();
+                securityCapabilities.AppContainerSid = appContainerSid;
+                securityCapabilities.Capabilities = IntPtr.Zero;
+                securityCapabilities.CapabilityCount = 0;
+                securityCapabilities.Reserved = 0;
+                int securityCapabilitiesSize = Marshal.SizeOf(typeof(SECURITY_CAPABILITIES));
+                securityCapabilitiesPointer = Marshal.AllocHGlobal(securityCapabilitiesSize);
+                Marshal.StructureToPtr(securityCapabilities, securityCapabilitiesPointer, false);
+                Check(UpdateProcThreadAttribute(
+                    attributeList,
+                    0,
+                    ProcThreadAttributeSecurityCapabilities,
+                    securityCapabilitiesPointer,
+                    new UIntPtr((uint)securityCapabilitiesSize),
+                    IntPtr.Zero,
+                    IntPtr.Zero
+                ), "set-appcontainer-security-capabilities");
+            }
+
             STARTUPINFOEX startup = new STARTUPINFOEX();
             startup.StartupInfo.cb = Marshal.SizeOf(typeof(STARTUPINFOEX));
             startup.StartupInfo.dwFlags = StartfUseStdHandles;
@@ -279,6 +396,22 @@ internal static class Program
             Check(created, "create-restricted-process");
             result.Launched = true;
 
+            if (args.AppContainerDeny)
+            {
+                Check(OpenProcessToken(process.hProcess, TokenQuery, out childToken), "open-appcontainer-process-token");
+                result.AppContainer = IsAppContainer(childToken);
+                result.AppContainerSidMatched = AppContainerSidMatches(childToken, appContainerSid);
+                result.CapabilityCount = TokenGroupCount(childToken, TokenCapabilities);
+                result.LowIntegrity = HasLowIntegrity(childToken);
+                result.EnabledPrivilegeCount = EnabledPrivilegeCount(childToken);
+                result.PrivilegesBounded = result.EnabledPrivilegeCount <= 1;
+                if (!result.AppContainer || !result.AppContainerSidMatched || result.CapabilityCount != 0 ||
+                    !result.LowIntegrity || !result.PrivilegesBounded)
+                {
+                    throw new LauncherException("appcontainer-token-evidence", 0);
+                }
+            }
+
             CloseHandle(stdoutWrite);
             stdoutWrite = IntPtr.Zero;
             CloseHandle(stderrWrite);
@@ -328,11 +461,24 @@ internal static class Program
             CloseIfValid(nullInput);
             if (attributeList != IntPtr.Zero) DeleteProcThreadAttributeList(attributeList);
             if (handleList != IntPtr.Zero) Marshal.FreeHGlobal(handleList);
+            if (securityCapabilitiesPointer != IntPtr.Zero) Marshal.FreeHGlobal(securityCapabilitiesPointer);
             if (attributeList != IntPtr.Zero) Marshal.FreeHGlobal(attributeList);
             CloseIfValid(job);
+            CloseIfValid(childToken);
             CloseIfValid(restrictedToken);
             CloseIfValid(processToken);
             if (lowSid != IntPtr.Zero) LocalFree(lowSid);
+            if (appContainerProfileCreated)
+            {
+                int deleteResult = DeleteAppContainerProfile(appContainerIdentity);
+                result.ProfileDeleted = deleteResult == 0;
+                if (deleteResult != 0 && result.ErrorStage == null)
+                {
+                    result.ErrorStage = "delete-appcontainer-profile";
+                    result.ErrorCode = deleteResult;
+                }
+            }
+            if (appContainerSid != IntPtr.Zero) FreeSid(appContainerSid);
         }
         return result;
     }
@@ -352,6 +498,224 @@ internal static class Program
         }
     }
 
+    private static void GrantDirectoryAccess(string path, SecurityIdentifier sid, FileSystemRights rights)
+    {
+        DirectoryInfo directory = new DirectoryInfo(path);
+        DirectorySecurity security = directory.GetAccessControl(AccessControlSections.Access);
+        security.AddAccessRule(new FileSystemAccessRule(
+            sid,
+            rights | FileSystemRights.Synchronize,
+            InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
+            PropagationFlags.None,
+            AccessControlType.Allow
+        ));
+        directory.SetAccessControl(security);
+    }
+
+    private static void HardenProtectedSentinel(string path)
+    {
+        SecurityIdentifier user = WindowsIdentity.GetCurrent().User;
+        if (user == null) throw new InvalidOperationException("Current user SID is unavailable.");
+        FileSecurity security = new FileSecurity();
+        security.SetOwner(user);
+        security.SetAccessRuleProtection(true, false);
+        security.AddAccessRule(new FileSystemAccessRule(user, FileSystemRights.FullControl, AccessControlType.Allow));
+        File.SetAccessControl(path, security);
+        using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
+        {
+            if (stream.Length == 0) throw new InvalidOperationException("Protected sentinel is empty.");
+        }
+    }
+
+    private static void RunAppContainerCanaries(
+        Arguments args,
+        IntPtr restrictedToken,
+        IntPtr appContainerSid,
+        IntPtr job,
+        LaunchResult result)
+    {
+        TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
+        listener.Start(1);
+        try
+        {
+            int port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            Dictionary<string, int> evidence = RunAppContainerCanaryChild(
+                args,
+                restrictedToken,
+                appContainerSid,
+                job,
+                port
+            );
+            result.FilesystemCanaryError = evidence["filesystemError"];
+            result.NetworkCanaryError = evidence["networkError"];
+            result.LoopbackAccepted = listener.Pending();
+            result.FilesystemCanaryDenied = evidence["appContainer"] == 1 &&
+                evidence["capabilityCount"] == 0 &&
+                result.FilesystemCanaryError == ErrorAccessDenied;
+            result.NetworkCanaryDenied = evidence["appContainer"] == 1 &&
+                evidence["capabilityCount"] == 0 &&
+                (result.NetworkCanaryError == WsaAccessDenied ||
+                 result.NetworkCanaryError == WsaTimedOut) &&
+                !result.LoopbackAccepted;
+        }
+        finally
+        {
+            listener.Stop();
+        }
+    }
+
+    private static Dictionary<string, int> RunAppContainerCanaryChild(
+        Arguments args,
+        IntPtr restrictedToken,
+        IntPtr appContainerSid,
+        IntPtr job,
+        int port)
+    {
+        IntPtr stdoutRead = IntPtr.Zero;
+        IntPtr stdoutWrite = IntPtr.Zero;
+        IntPtr stderrRead = IntPtr.Zero;
+        IntPtr stderrWrite = IntPtr.Zero;
+        IntPtr nullInput = IntPtr.Zero;
+        IntPtr attributeList = IntPtr.Zero;
+        IntPtr handleList = IntPtr.Zero;
+        IntPtr securityCapabilitiesPointer = IntPtr.Zero;
+        PROCESS_INFORMATION process = new PROCESS_INFORMATION();
+        try
+        {
+            SECURITY_ATTRIBUTES pipeSecurity = new SECURITY_ATTRIBUTES();
+            pipeSecurity.nLength = Marshal.SizeOf(typeof(SECURITY_ATTRIBUTES));
+            pipeSecurity.bInheritHandle = true;
+            Check(CreatePipe(out stdoutRead, out stdoutWrite, ref pipeSecurity, 0), "create-canary-stdout-pipe");
+            Check(SetHandleInformation(stdoutRead, HandleFlagInherit, 0), "protect-canary-stdout-reader");
+            Check(CreatePipe(out stderrRead, out stderrWrite, ref pipeSecurity, 0), "create-canary-stderr-pipe");
+            Check(SetHandleInformation(stderrRead, HandleFlagInherit, 0), "protect-canary-stderr-reader");
+            nullInput = CreateFile("NUL", GenericRead, FileShareRead | FileShareWrite, ref pipeSecurity, OpenExisting, FileAttributeNormal, IntPtr.Zero);
+            Check(nullInput != new IntPtr(-1), "open-canary-null-input");
+
+            UIntPtr attributeBytes = UIntPtr.Zero;
+            InitializeProcThreadAttributeList(IntPtr.Zero, 2, 0, ref attributeBytes);
+            attributeList = Marshal.AllocHGlobal((int)attributeBytes.ToUInt64());
+            Check(InitializeProcThreadAttributeList(attributeList, 2, 0, ref attributeBytes), "initialize-canary-attributes");
+            handleList = Marshal.AllocHGlobal(IntPtr.Size * 3);
+            Marshal.WriteIntPtr(handleList, 0, nullInput);
+            Marshal.WriteIntPtr(handleList, IntPtr.Size, stdoutWrite);
+            Marshal.WriteIntPtr(handleList, IntPtr.Size * 2, stderrWrite);
+            Check(UpdateProcThreadAttribute(
+                attributeList,
+                0,
+                ProcThreadAttributeHandleList,
+                handleList,
+                new UIntPtr((uint)(IntPtr.Size * 3)),
+                IntPtr.Zero,
+                IntPtr.Zero
+            ), "set-canary-handle-allowlist");
+
+            SECURITY_CAPABILITIES securityCapabilities = new SECURITY_CAPABILITIES();
+            securityCapabilities.AppContainerSid = appContainerSid;
+            int securityCapabilitiesSize = Marshal.SizeOf(typeof(SECURITY_CAPABILITIES));
+            securityCapabilitiesPointer = Marshal.AllocHGlobal(securityCapabilitiesSize);
+            Marshal.StructureToPtr(securityCapabilities, securityCapabilitiesPointer, false);
+            Check(UpdateProcThreadAttribute(
+                attributeList,
+                0,
+                ProcThreadAttributeSecurityCapabilities,
+                securityCapabilitiesPointer,
+                new UIntPtr((uint)securityCapabilitiesSize),
+                IntPtr.Zero,
+                IntPtr.Zero
+            ), "set-canary-appcontainer");
+
+            string executable = args.CanaryExecutable;
+            string[] canaryArguments = {
+                "--protected-sentinel",
+                args.ProtectedSentinel,
+                "--loopback-port",
+                port.ToString()
+            };
+            STARTUPINFOEX startup = new STARTUPINFOEX();
+            startup.StartupInfo.cb = Marshal.SizeOf(typeof(STARTUPINFOEX));
+            startup.StartupInfo.dwFlags = StartfUseStdHandles;
+            startup.StartupInfo.hStdInput = nullInput;
+            startup.StartupInfo.hStdOutput = stdoutWrite;
+            startup.StartupInfo.hStdError = stderrWrite;
+            startup.lpAttributeList = attributeList;
+            StringBuilder commandLine = new StringBuilder(BuildCommandLine(executable, canaryArguments));
+            uint flags = CreateSuspended | CreateNoWindow | CreateUnicodeEnvironment | ExtendedStartupInfoPresent;
+            Check(CreateProcessAsUser(
+                restrictedToken,
+                executable,
+                commandLine,
+                IntPtr.Zero,
+                IntPtr.Zero,
+                true,
+                flags,
+                IntPtr.Zero,
+                args.SandboxRoot,
+                ref startup,
+                out process
+            ), "create-appcontainer-canary");
+            CloseHandle(stdoutWrite);
+            stdoutWrite = IntPtr.Zero;
+            CloseHandle(stderrWrite);
+            stderrWrite = IntPtr.Zero;
+            Check(AssignProcessToJobObject(job, process.hProcess), "assign-canary-to-job");
+            Task<byte[]> stdoutTask = ReadBoundedAsync(stdoutRead);
+            Task<byte[]> stderrTask = ReadBoundedAsync(stderrRead);
+            uint resumed = ResumeThread(process.hThread);
+            if (resumed == UInt32.MaxValue) ThrowWin32("resume-appcontainer-canary");
+            uint wait = WaitForSingleObject(process.hProcess, 10000);
+            if (wait != WaitObject0)
+            {
+                TerminateProcess(process.hProcess, 0x7d);
+                WaitForSingleObject(process.hProcess, 5000);
+                throw new LauncherException("wait-appcontainer-canary", unchecked((int)wait));
+            }
+            uint exitCode;
+            Check(GetExitCodeProcess(process.hProcess, out exitCode), "read-canary-exit");
+            Task.WaitAll(new Task[] { stdoutTask, stderrTask }, 5000);
+            byte[] stdout = stdoutTask.IsCompleted ? stdoutTask.Result : new byte[0];
+            byte[] stderr = stderrTask.IsCompleted ? stderrTask.Result : new byte[0];
+            if (exitCode != 0 || stderr.Length != 0) throw new InvalidOperationException("AppContainer canary failed closed.");
+            return ParseCanaryEvidence(Encoding.UTF8.GetString(stdout).Trim());
+        }
+        finally
+        {
+            CloseIfValid(process.hThread);
+            CloseIfValid(process.hProcess);
+            CloseIfValid(stdoutRead);
+            CloseIfValid(stdoutWrite);
+            CloseIfValid(stderrRead);
+            CloseIfValid(stderrWrite);
+            CloseIfValid(nullInput);
+            if (attributeList != IntPtr.Zero) DeleteProcThreadAttributeList(attributeList);
+            if (handleList != IntPtr.Zero) Marshal.FreeHGlobal(handleList);
+            if (securityCapabilitiesPointer != IntPtr.Zero) Marshal.FreeHGlobal(securityCapabilitiesPointer);
+            if (attributeList != IntPtr.Zero) Marshal.FreeHGlobal(attributeList);
+        }
+    }
+
+    private static Dictionary<string, int> ParseCanaryEvidence(string value)
+    {
+        Dictionary<string, int> parsed = new Dictionary<string, int>(StringComparer.Ordinal);
+        foreach (string field in value.Split(';'))
+        {
+            string[] pair = field.Split(new char[] { '=' }, 2);
+            int number;
+            if (pair.Length != 2 || parsed.ContainsKey(pair[0]) || !Int32.TryParse(pair[1], out number))
+            {
+                throw new InvalidOperationException("AppContainer canary protocol is invalid.");
+            }
+            parsed.Add(pair[0], number);
+        }
+        string[] keys = { "appContainer", "capabilityCount", "filesystemError", "networkError" };
+        if (parsed.Count != keys.Length) throw new InvalidOperationException("AppContainer canary protocol is incomplete.");
+        foreach (string key in keys)
+        {
+            if (!parsed.ContainsKey(key)) throw new InvalidOperationException("AppContainer canary field is missing.");
+        }
+        return parsed;
+    }
+
     private static void SetTokenIntegrity(IntPtr token, IntPtr sid)
     {
         int sidLength = (int)GetLengthSid(sid);
@@ -414,6 +778,51 @@ internal static class Program
         }
     }
 
+    private static bool IsAppContainer(IntPtr token)
+    {
+        IntPtr buffer = QueryTokenInformation(token, TokenIsAppContainer);
+        try
+        {
+            return Marshal.ReadInt32(buffer) != 0;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+
+    private static int TokenGroupCount(IntPtr token, int informationClass)
+    {
+        IntPtr buffer = QueryTokenInformation(token, informationClass);
+        try
+        {
+            return Marshal.ReadInt32(buffer);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+
+    private static bool AppContainerSidMatches(IntPtr token, IntPtr expectedSid)
+    {
+        IntPtr buffer = QueryTokenInformation(token, TokenAppContainerSid);
+        try
+        {
+            TOKEN_APPCONTAINER_INFORMATION information =
+                (TOKEN_APPCONTAINER_INFORMATION)Marshal.PtrToStructure(
+                    buffer,
+                    typeof(TOKEN_APPCONTAINER_INFORMATION)
+                );
+            return information.TokenAppContainer != IntPtr.Zero &&
+                EqualSid(information.TokenAppContainer, expectedSid);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+
     private static IntPtr QueryTokenInformation(IntPtr token, int informationClass)
     {
         int length = 0;
@@ -529,12 +938,8 @@ internal static class Program
 
     private static string ToJson(LaunchResult result)
     {
-        return "{" +
-            "\"protocol\":\"" + Protocol + "\"," +
-            "\"launched\":" + Bool(result.Launched) + "," +
-            "\"timedOut\":" + Bool(result.TimedOut) + "," +
-            "\"exitCode\":" + (result.ExitCode.HasValue ? result.ExitCode.Value.ToString() : "null") + "," +
-            "\"isolation\":{" +
+        string isolation = result.AppContainerMode
+            ?
                 "\"filteredToken\":" + Bool(result.FilteredToken) + "," +
                 "\"disableMaxPrivilege\":" + Bool(result.DisableMaxPrivilege) + "," +
                 "\"enabledPrivilegeCount\":" + result.EnabledPrivilegeCount.ToString() + "," +
@@ -546,8 +951,36 @@ internal static class Program
                 "\"activeProcessLimit\":" + Bool(result.ActiveProcessLimit) + "," +
                 "\"processMemoryLimit\":" + Bool(result.ProcessMemoryLimit) + "," +
                 "\"uiRestrictions\":" + Bool(result.UiRestrictions) + "," +
-                "\"writableTempLowIntegrity\":" + Bool(result.WritableTempLowIntegrity) +
-            "}," +
+                "\"appContainer\":" + Bool(result.AppContainer) + "," +
+                "\"appContainerSidMatched\":" + Bool(result.AppContainerSidMatched) + "," +
+                "\"capabilityCount\":" + result.CapabilityCount.ToString() + "," +
+                "\"snapshotReadExecuteGrant\":" + Bool(result.SnapshotReadExecuteGrant) + "," +
+                "\"writableTempModifyGrant\":" + Bool(result.WritableTempModifyGrant) + "," +
+                "\"filesystemCanaryDenied\":" + Bool(result.FilesystemCanaryDenied) + "," +
+                "\"filesystemCanaryError\":" + result.FilesystemCanaryError.ToString() + "," +
+                "\"networkCanaryDenied\":" + Bool(result.NetworkCanaryDenied) + "," +
+                "\"networkCanaryError\":" + result.NetworkCanaryError.ToString() + "," +
+                "\"loopbackAccepted\":" + Bool(result.LoopbackAccepted) + "," +
+                "\"profileDeleted\":" + Bool(result.ProfileDeleted)
+            :
+                "\"filteredToken\":" + Bool(result.FilteredToken) + "," +
+                "\"disableMaxPrivilege\":" + Bool(result.DisableMaxPrivilege) + "," +
+                "\"enabledPrivilegeCount\":" + result.EnabledPrivilegeCount.ToString() + "," +
+                "\"privilegesBounded\":" + Bool(result.PrivilegesBounded) + "," +
+                "\"lowIntegrity\":" + Bool(result.LowIntegrity) + "," +
+                "\"assignedBeforeResume\":" + Bool(result.AssignedBeforeResume) + "," +
+                "\"handleAllowlist\":" + Bool(result.HandleAllowlist) + "," +
+                "\"killOnClose\":" + Bool(result.KillOnClose) + "," +
+                "\"activeProcessLimit\":" + Bool(result.ActiveProcessLimit) + "," +
+                "\"processMemoryLimit\":" + Bool(result.ProcessMemoryLimit) + "," +
+                "\"uiRestrictions\":" + Bool(result.UiRestrictions) + "," +
+                "\"writableTempLowIntegrity\":" + Bool(result.WritableTempLowIntegrity);
+        return "{" +
+            "\"protocol\":\"" + (result.AppContainerMode ? AppContainerProtocol : Protocol) + "\"," +
+            "\"launched\":" + Bool(result.Launched) + "," +
+            "\"timedOut\":" + Bool(result.TimedOut) + "," +
+            "\"exitCode\":" + (result.ExitCode.HasValue ? result.ExitCode.Value.ToString() : "null") + "," +
+            "\"isolation\":{" + isolation + "}," +
             "\"stdoutBase64\":\"" + Convert.ToBase64String(result.StandardOutput) + "\"," +
             "\"stderrBase64\":\"" + Convert.ToBase64String(result.StandardError) + "\"," +
             "\"errorStage\":" + (result.ErrorStage == null ? "null" : "\"" + EscapeJson(result.ErrorStage) + "\"") + "," +
@@ -597,6 +1030,16 @@ internal static class Program
     [StructLayout(LayoutKind.Sequential)]
     private struct TOKEN_MANDATORY_LABEL { public SID_AND_ATTRIBUTES Label; }
     [StructLayout(LayoutKind.Sequential)]
+    private struct TOKEN_APPCONTAINER_INFORMATION { public IntPtr TokenAppContainer; }
+    [StructLayout(LayoutKind.Sequential)]
+    private struct SECURITY_CAPABILITIES
+    {
+        public IntPtr AppContainerSid;
+        public IntPtr Capabilities;
+        public uint CapabilityCount;
+        public uint Reserved;
+    }
+    [StructLayout(LayoutKind.Sequential)]
     private struct SECURITY_ATTRIBUTES { public int nLength; public IntPtr lpSecurityDescriptor; [MarshalAs(UnmanagedType.Bool)] public bool bInheritHandle; }
     [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
     private struct STARTUPINFO
@@ -643,6 +1086,7 @@ internal static class Program
     [DllImport("kernel32.dll", SetLastError = true)] private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
     [DllImport("kernel32.dll", SetLastError = true)] private static extern uint ResumeThread(IntPtr thread);
     [DllImport("kernel32.dll", SetLastError = true)] private static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
+    [DllImport("kernel32.dll", SetLastError = true)] private static extern bool TerminateProcess(IntPtr process, uint exitCode);
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
     [DllImport("kernel32.dll", SetLastError = true)] private static extern bool SetInformationJobObject(IntPtr job, int informationClass, IntPtr information, uint length);
     [DllImport("kernel32.dll", SetLastError = true)] private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
@@ -658,10 +1102,16 @@ internal static class Program
     [DllImport("advapi32.dll", SetLastError = true)] private static extern IntPtr GetSidSubAuthorityCount(IntPtr sid);
     [DllImport("advapi32.dll", SetLastError = true)] private static extern IntPtr GetSidSubAuthority(IntPtr sid, uint subAuthority);
     [DllImport("advapi32.dll", SetLastError = true)] private static extern uint GetLengthSid(IntPtr sid);
+    [DllImport("advapi32.dll", SetLastError = true)] private static extern bool EqualSid(IntPtr firstSid, IntPtr secondSid);
+    [DllImport("advapi32.dll", SetLastError = true)] private static extern IntPtr FreeSid(IntPtr sid);
     [DllImport("advapi32.dll", SetLastError = true)] private static extern bool CopySid(uint destinationLength, IntPtr destination, IntPtr source);
     [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)] private static extern bool ConvertStringSidToSid(string sid, out IntPtr binarySid);
     [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)] private static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string descriptor, uint revision, out IntPtr securityDescriptor, out uint size);
     [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)] private static extern bool SetFileSecurity(string path, uint securityInformation, IntPtr securityDescriptor);
     [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     private static extern bool CreateProcessAsUser(IntPtr token, string applicationName, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inheritHandles, uint creationFlags, IntPtr environment, string currentDirectory, ref STARTUPINFOEX startupInfo, out PROCESS_INFORMATION processInformation);
+    [DllImport("userenv.dll", CharSet = CharSet.Unicode)]
+    private static extern int CreateAppContainerProfile(string appContainerName, string displayName, string description, IntPtr capabilities, uint capabilityCount, out IntPtr appContainerSid);
+    [DllImport("userenv.dll", CharSet = CharSet.Unicode)]
+    private static extern int DeleteAppContainerProfile(string appContainerName);
 }