mcp-pacemaker 2.0.2 → 2.1.0

package/bin/windows-task-channel/TaskChannelGuard.build.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": 1,
+  "binary": "TaskChannelGuard.exe",
+  "binarySha256": "32cb53e86a72cf26d1159d2a3ba85a9ca7e91f795cb06372f8881b03a2fe7079",
+  "inputs": {
+    "targetFramework": ".NETFramework,Version=v4.6.2",
+    "platform": "AnyCPU",
+    "compilerVersion": "5.9.0-1.26357.3 (35d9211b841e7613c1d2f8f5af6d628ace696c4c)",
+    "compilerSha256": "3aafb7b9c54fa31a7092af35148971ee616965e7f9a0b80fb7fdc4bdd1d1a555",
+    "compilerArguments": [
+      "/nologo",
+      "/noconfig",
+      "/nostdlib+",
+      "/target:exe",
+      "/platform:anycpu",
+      "/langversion:7.3",
+      "/optimize+",
+      "/debug-",
+      "/deterministic+",
+      "/checked-",
+      "/unsafe-",
+      "/warn:4",
+      "/warnaserror+",
+      "/utf8output"
+    ],
+    "pathMap": "/_/mcp-pacemaker/windows-task-channel",
+    "sourceEncoding": "UTF-8 without BOM, LF line endings",
+    "sourceSha256": {
+      "AssemblyInfo.cs": "cd8b74ed1747f88261085f206ada2aa73f61a90f633fb7f0394c492e2d57e91a",
+      "ChannelCliContext.cs": "d99dcd49c1117a2581e4d9818010eed540fa60a880f2920c174a210e6d369348",
+      "ChannelFiles.cs": "ce4870cb839d49f84868014078a88c869f94b0604d985a64720e93423414d476",
+      "ChannelNative.cs": "fe19cfb88936273d466dd4e121175a3477ff6ae821306038fd3da455e9608b35",
+      "ChannelSession.cs": "9be542fac1ed3fb73b3d6088d7a46f58e6dd5e50c249abd92aa23cf7a051d943",
+      "TaskChannelGuard.cs": "3e6d1bf22da763a30c8abda1c032f7dbb73690679cb8d83d71ed4bd8cd706558"
+    },
+    "buildScriptSha256": "666cf533c635c3f01d34eed899f7d61d259bb777c442bde0bc38af2cacd3f7d6",
+    "referenceSha256": {
+      "mscorlib.dll": "7118fe658567606fa0538f7b5a2071e4606756c07e9062e1e5b24fa49e97d1f6",
+      "System.dll": "b76822f9c08aff597120e3167b3e0fbda836d6bc6f14bc4bc2eeffab5b2c6125",
+      "System.Core.dll": "774e965a6c25891a96d6d3b838ae10226ed9963a73b09e4be7c2ec275ffb5886",
+      "System.Management.dll": "bc35cddea6226db4d428a9fb70fcefe321a2af003c947edb812f3e911f8e4094",
+      "System.Web.Extensions.dll": "7a32bf3263aebed93c3a0847294aebdde15f7427541ed223a4cc4eb93c36d556"
+    }
+  }
+}

package/bin/windows-task-channel/src/AssemblyInfo.cs

@@ -0,0 +1,8 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("MCP Task Channel Guard")]
+[assembly: AssemblyDescription("One-operation query-only Windows worker pipe identity")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: ComVisible(false)]

package/bin/windows-task-channel/src/ChannelCliContext.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+internal sealed class ChannelCliContext
+{
+    private readonly ChannelNative native;
+    private readonly Action checkpoint;
+
+    internal ChannelCliContext(ChannelNative nativeApi, Action check)
+    {
+        native = nativeApi;
+        checkpoint = check;
+    }
+
+    internal int Parent(ProcessHandle self, int selfPid)
+    {
+        uint pipeOwner;
+        if (!ContextApi.GetNamedPipeServerProcessId(ContextApi.GetStdHandle(-10), out pipeOwner))
+            throw new ContextObservationException("CLI_PARENT_PIPE_UNVERIFIED");
+        var information = new ContextApi.BasicInformation();
+        int size = Marshal.SizeOf(information);
+        int returned;
+        int status = ContextApi.NtQueryInformationProcess(self, 0, out information, size, out returned);
+        bool valid = (IntPtr.Size == 4 || IntPtr.Size == 8) &&
+            size == 6 * IntPtr.Size &&
+            status == 0 &&
+            returned == size &&
+            information.processId.ToInt64() == selfPid &&
+            information.parentReserved.ToInt64() == pipeOwner &&
+            pipeOwner > 0 &&
+            pipeOwner <= int.MaxValue &&
+            pipeOwner != selfPid;
+        if (!valid) throw new ContextObservationException("CLI_PARENT_LAYOUT_OR_BINDING_UNVERIFIED");
+        return checked((int)pipeOwner);
+    }
+
+    internal ProcessHandle OpenParent(int pid)
+    {
+        var handle = ChannelApi.OpenProcess(0x101400, false, pid);
+        if (handle.IsInvalid)
+        {
+            handle.Dispose();
+            throw new ContextObservationException("CLI_PARENT_QUERY_ACCESS_DENIED");
+        }
+        return handle;
+    }
+
+    internal ContextResult Observe(ProcessHandle parent, Identity identity)
+    {
+        var result = new ContextResult
+        {
+            proofScope = "cli-effective-context-snapshot",
+            reason = "CONTEXT_UNVERIFIED",
+            observation = new ContextObservation
+            {
+                method = "pss-threads-held-token-query", processAccess = "0x101400",
+                captureFlags = "0x80", threadContextFlags = 0, atomicFutureProtection = false
+            }
+        };
+        try
+        {
+            checkpoint();
+            var firstFacts = native.Facts(parent, false, checkpoint);
+            result.actorFacts = firstFacts;
+            if (firstFacts.ownerSid != identity.ownerSid ||
+                firstFacts.sessionId != identity.sessionId) throw new ContextObservationException("PRIMARY_TOKEN_CHANGED");
+            if (firstFacts.elevated ||
+                firstFacts.enabledAdministrator) throw new ContextObservationException("PRIMARY_CONTEXT_PRIVILEGED");
+            if (firstFacts.guardThreadImpersonating) throw new ContextObservationException("GUARD_THREAD_IMPERSONATING");
+            var threads = native.ObserveThreads(parent, checkpoint);
+            result.observation.threadCount = threads.count;
+            if (threads.impersonating) throw new ContextObservationException("THREAD_TOKEN_OBSERVED");
+            var finalFacts = native.Facts(parent, false, checkpoint);
+            result.actorFacts = finalFacts;
+            result.observation.primaryStable = SamePrimary(firstFacts, finalFacts);
+            result.observation.completeStableThreadSet = true;
+            if (!result.observation.primaryStable) throw new ContextObservationException("PRIMARY_TOKEN_CHANGED");
+            finalFacts.parentThreadImpersonation = "observed-none";
+            finalFacts.parentThreadQueryError = null;
+            result.ordinaryEligible = Eligible(finalFacts, result.observation);
+            result.reason = result.ordinaryEligible ? "OBSERVED_NON_ELEVATED_NO_IMPERSONATION" : "CONTEXT_NOT_ORDINARY";
+        }
+        catch (ContextObservationException error)
+        {
+            result.reason = error.Message;
+            if (result.actorFacts != null)
+            {
+                result.actorFacts.parentThreadImpersonation = error.Message == "THREAD_TOKEN_OBSERVED"
+                    ? "observed-impersonating" : "unverified";
+                result.actorFacts.parentThreadQueryError = error.Message;
+            }
+        }
+        catch (Win32Exception error)
+        {
+            result.reason = "CONTEXT_QUERY_FAILED_" + error.NativeErrorCode.ToString(CultureInfo.InvariantCulture);
+        }
+        catch (EntryPointNotFoundException) { result.reason = "CONTEXT_API_UNSUPPORTED"; }
+        catch (DllNotFoundException) { result.reason = "CONTEXT_API_UNAVAILABLE"; }
+        checkpoint();
+        result.observation.observedAt = DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture);
+        return result;
+    }
+
+    internal bool Eligible(ActorFacts facts, ContextObservation observation)
+    {
+        return facts != null &&
+            observation != null &&
+            !facts.elevated &&
+            !facts.enabledAdministrator &&
+            !facts.guardThreadImpersonating &&
+            facts.parentThreadImpersonation == "observed-none" &&
+            observation.completeStableThreadSet &&
+            observation.primaryStable &&
+            observation.threadCount > 0 &&
+            observation.threadCount <= 128 &&
+            !observation.atomicFutureProtection;
+    }
+
+    private bool SamePrimary(ActorFacts first, ActorFacts second)
+    {
+        return first.ownerSid == second.ownerSid &&
+            first.sessionId == second.sessionId &&
+            first.elevated == second.elevated &&
+            first.enabledAdministrator == second.enabledAdministrator &&
+            first.restricted == second.restricted &&
+            first.appContainer == second.appContainer &&
+            first.guardThreadImpersonating == second.guardThreadImpersonating;
+    }
+
+}
+
+internal sealed class ContextObservationException : InvalidOperationException
+{
+    internal ContextObservationException(string reason) : base(reason) { }
+}
+
+internal sealed class ContextResult
+{
+    public string proofScope { get; set; }
+    public bool ordinaryEligible { get; set; }
+    public string reason { get; set; }
+    public ActorFacts actorFacts { get; set; }
+    public ContextObservation observation { get; set; }
+}
+
+internal sealed class ContextObservation
+{
+    public string method { get; set; }
+    public string processAccess { get; set; }
+    public string captureFlags { get; set; }
+    public int threadContextFlags { get; set; }
+    public int threadCount { get; set; }
+    public bool completeStableThreadSet { get; set; }
+    public bool primaryStable { get; set; }
+    public bool atomicFutureProtection { get; set; }
+    public string observedAt { get; set; }
+}
+
+internal static class ContextApi
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct BasicInformation
+    {
+        internal IntPtr reserved1, peb, reserved2, reserved3, processId, parentReserved;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct FileTime { internal uint low, high; }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct ThreadInformation { internal uint count, contextLength; }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct ThreadEntry
+    {
+        internal uint exitStatus;
+        internal IntPtr teb;
+        internal uint processId, threadId;
+        internal UIntPtr affinity;
+        internal int priority, basePriority;
+        internal IntPtr lastArgument;
+        internal ushort syscall;
+        internal FileTime creation, exit, kernel, user;
+        internal IntPtr start;
+        internal FileTime capture;
+        internal uint flags;
+        internal ushort suspendCount, contextSize;
+        internal IntPtr context;
+    }
+    [DllImport("kernel32.dll")] internal static extern IntPtr GetStdHandle(int kind);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool GetNamedPipeServerProcessId(IntPtr pipe, out uint pid);
+    [DllImport("ntdll.dll")]
+    internal static extern int NtQueryInformationProcess(ProcessHandle process, int kind, out BasicInformation info, int length, out int returned);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    internal static extern ProcessHandle OpenThread(uint access, [MarshalAs(UnmanagedType.Bool)] bool inherit, uint tid);
+    [DllImport("kernel32.dll")] internal static extern void GetSystemTimePreciseAsFileTime(out long time);
+    [DllImport("kernel32.dll")] internal static extern IntPtr GetCurrentProcess();
+    [DllImport("kernel32.dll")]
+    internal static extern uint PssCaptureSnapshot(ProcessHandle process, uint flags, uint contextFlags, out IntPtr snapshot);
+    [DllImport("kernel32.dll")] internal static extern uint PssFreeSnapshot(IntPtr process, IntPtr snapshot);
+    [DllImport("kernel32.dll")]
+    internal static extern uint PssQuerySnapshot(IntPtr snapshot, int kind, out ThreadInformation information, uint length);
+    [DllImport("kernel32.dll")] internal static extern uint PssWalkMarkerCreate(IntPtr allocator, out IntPtr marker);
+    [DllImport("kernel32.dll")] internal static extern uint PssWalkMarkerFree(IntPtr marker);
+    [DllImport("kernel32.dll")]
+    internal static extern uint PssWalkSnapshot(IntPtr snapshot, int kind, IntPtr marker, out ThreadEntry entry, uint length);
+}

package/bin/windows-task-channel/src/ChannelFiles.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Cryptography;
+using System.Security.Principal;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
+
+internal sealed class ChannelFiles : IDisposable
+{
+    private readonly ChannelNative native = new ChannelNative();
+    private readonly List<IDisposable> held = new List<IDisposable>();
+    private readonly string actor;
+    private readonly HashSet<string> trusted;
+    private readonly Action checkpoint;
+
+    internal ChannelFiles(string actorSid, Action check = null)
+    {
+        checkpoint = check;
+        actor = actorSid;
+        trusted = new HashSet<string>(StringComparer.Ordinal)
+        {
+            actor, "S-1-5-18", "S-1-5-32-544",
+            "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"
+        };
+    }
+
+    internal string PathValue(string path)
+    {
+        bool absolute = path != null &&
+            path.Length > 3 &&
+            char.IsLetter(path[0]) &&
+            path[1] == ':' &&
+            (path[2] == '\\' || path[2] == '/');
+        if (!absolute ||
+            path.IndexOf(':', 2) >= 0 ||
+            path.IndexOf('\0') >= 0) throw new InvalidOperationException("LOCAL_ABSOLUTE_PATH_REQUIRED");
+        return Path.GetFullPath(path);
+    }
+
+    internal string Digest(byte[] bytes)
+    {
+        using (var hash = SHA256.Create())
+            return BitConverter.ToString(hash.ComputeHash(bytes)).Replace("-", "").ToLowerInvariant();
+    }
+
+    internal string Hash(Stream stream)
+    {
+        stream.Position = 0;
+        using (var hash = SHA256.Create())
+        {
+            var digest = BitConverter.ToString(hash.ComputeHash(stream)).Replace("-", "").ToLowerInvariant();
+            stream.Position = 0;
+            return digest;
+        }
+    }
+
+    internal void Security(string path, bool directory, bool fullWrite)
+    {
+        FileSystemSecurity descriptor = directory
+            ? (FileSystemSecurity)Directory.GetAccessControl(path, AccessControlSections.Owner | AccessControlSections.Access)
+            : File.GetAccessControl(path, AccessControlSections.Owner | AccessControlSections.Access);
+        var owner = descriptor.GetOwner(typeof(SecurityIdentifier)).Value;
+        if (!trusted.Contains(owner)) throw new InvalidOperationException("UNTRUSTED_PATH_OWNER");
+        var binary = new RawSecurityDescriptor(descriptor.GetSecurityDescriptorBinaryForm(), 0);
+        if (binary.DiscretionaryAcl == null) throw new InvalidOperationException("NULL_PATH_DACL");
+        int dangerous = 0x10000 | 0x40000 | 0x80000 | 0x40;
+        if (fullWrite) dangerous |= 2 | 4 | 0x10 | 0x100;
+        foreach (GenericAce ace in binary.DiscretionaryAcl)
+        {
+            if ((ace.AceFlags & AceFlags.InheritOnly) != 0) continue;
+            var common = ace as CommonAce;
+            if (common == null ||
+                common.IsCallback) throw new InvalidOperationException("UNSUPPORTED_PATH_ACE");
+            if (common.AceQualifier != AceQualifier.AccessAllowed) continue;
+            int mask = common.AccessMask;
+            bool writable = (mask & dangerous) != 0 ||
+                (mask & unchecked((int)0x50000000)) != 0;
+            if (writable &&
+                !trusted.Contains(common.SecurityIdentifier.Value))
+                throw new InvalidOperationException("UNTRUSTED_PATH_WRITER");
+        }
+    }
+
+    internal string Owner(string path)
+    {
+        return File.GetAccessControl(path, AccessControlSections.Owner).GetOwner(typeof(SecurityIdentifier)).Value;
+    }
+
+    internal void Chain(string path, bool protectWriters)
+    {
+        var full = PathValue(path);
+        var paths = new List<string>();
+        var current = full;
+        while (current != null)
+        {
+            paths.Add(current);
+            current = Path.GetDirectoryName(current);
+        }
+        paths.Reverse();
+        foreach (var item in paths)
+        {
+            HoldPath(item, protectWriters, item == full);
+        }
+    }
+
+    internal bool HoldPath(string path, bool protectWriters, bool fullWrite)
+    {
+        if (checkpoint != null) checkpoint();
+        var security = new ChannelApi.SecurityAttributes { length = Marshal.SizeOf(typeof(ChannelApi.SecurityAttributes)) };
+        var handle = ChannelApi.CreateFileW(path, 0x20080, 3, ref security, 3, 0x02200000, IntPtr.Zero);
+        if (handle.IsInvalid)
+        {
+            handle.Dispose();
+            throw new InvalidOperationException("PATH_HOLD_DENIED");
+        }
+        held.Add(handle);
+        ChannelApi.FileInformation information;
+        native.Require(ChannelApi.GetFileInformationByHandle(handle, out information));
+        if ((information.attributes & 0x400) != 0) throw new InvalidOperationException("REPARSE_PATH_REFUSED");
+        bool directory = (information.attributes & 0x10) != 0;
+        if (protectWriters) Security(path, directory, fullWrite || !directory);
+        if (checkpoint != null) checkpoint();
+        return directory;
+    }
+
+    internal FileStream HoldFile(string path, bool protectWriters)
+    {
+        path = PathValue(path);
+        Chain(path, protectWriters);
+        var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+        held.Add(stream);
+        return stream;
+    }
+
+    internal string Canonical(FileStream stream)
+    {
+        var text = new StringBuilder(32768);
+        uint length = ChannelApi.GetFinalPathNameByHandleW(stream.SafeFileHandle, text, text.Capacity, 0);
+        if (length < 1 ||
+            length >= text.Capacity) throw new InvalidOperationException("CANONICAL_PATH_UNAVAILABLE");
+        var path = text.ToString();
+        if (!path.StartsWith(@"\\?\", StringComparison.Ordinal)) throw new InvalidOperationException("CANONICAL_PATH_UNSUPPORTED");
+        return PathValue(path.Substring(4));
+    }
+
+    internal T WithDescriptor<T>(string targetSid, bool directory, Func<ChannelApi.SecurityAttributes, T> action, bool pipe = false)
+    {
+        var target = new SecurityIdentifier(targetSid).Value;
+        var rights = pipe ? "0x12019f" : directory ? "0x1200a9" : "0x120089";
+        var inherit = directory ? "OICI" : "";
+        var sddl = "O:" + actor + "G:" + actor + "D:P(A;" + inherit + ";FA;;;" + actor +
+            ")(A;" + inherit + ";FA;;;SY)";
+        if (target != actor) sddl += "(A;" + inherit + ";" + rights + ";;;" + target + ")";
+        var descriptor = new RawSecurityDescriptor(sddl);
+        var bytes = new byte[descriptor.BinaryLength];
+        descriptor.GetBinaryForm(bytes, 0);
+        var memory = Marshal.AllocHGlobal(bytes.Length);
+        try
+        {
+            Marshal.Copy(bytes, 0, memory, bytes.Length);
+            return action(new ChannelApi.SecurityAttributes
+            {
+                length = Marshal.SizeOf(typeof(ChannelApi.SecurityAttributes)),
+                descriptor = memory, inherit = false
+            });
+        }
+        finally { Marshal.FreeHGlobal(memory); }
+    }
+
+    internal void CreateDirectory(string path, string targetSid)
+    {
+        WithDescriptor(targetSid, true, security =>
+        {
+            native.Require(ChannelApi.CreateDirectoryW(path, ref security));
+            return true;
+        });
+    }
+
+    internal FileStream CreateManifest(string path, string targetSid, byte[] bytes)
+    {
+        var handle = WithDescriptor(targetSid, false, security =>
+            ChannelApi.CreateFileW(path, 0xC0000000, 1, ref security, 1, 0x80, IntPtr.Zero));
+        if (handle.IsInvalid)
+        {
+            handle.Dispose();
+            throw new InvalidOperationException("MANIFEST_CREATE_DENIED");
+        }
+        using (var stream = new FileStream(handle, FileAccess.ReadWrite))
+        {
+            stream.Write(bytes, 0, bytes.Length);
+            stream.Flush(true);
+        }
+        return HoldFile(path, true);
+    }
+
+    internal Dictionary<string, object> InspectRoot(string root)
+    {
+        root = PathValue(root);
+        Chain(root, true);
+        int directories = 0, files = 0;
+        var pending = new Queue<string>();
+        pending.Enqueue(root);
+        while (pending.Count != 0)
+        {
+            if (checkpoint != null) checkpoint();
+            var directory = pending.Dequeue();
+            if (++directories > 2048) throw new InvalidOperationException("CODE_DIRECTORY_BOUND");
+            foreach (var path in Directory.EnumerateFileSystemEntries(directory))
+            {
+                bool isDirectory = HoldPath(path, true, true);
+                if (isDirectory) pending.Enqueue(path);
+                else if (++files > 16384) throw new InvalidOperationException("CODE_FILE_BOUND");
+            }
+            if (checkpoint != null) checkpoint();
+        }
+        return new Dictionary<string, object>
+        {
+            { "root", root }, { "directories", directories }, { "files", files },
+            { "protection", "observed-owner-and-allow-writers" }, { "loadedCodeAttestation", false }
+        };
+    }
+
+    public void Dispose()
+    {
+        for (int index = held.Count - 1; index >= 0; index--) held[index].Dispose();
+        held.Clear();
+    }
+}