windows-development-sandbox 1.13.0 → 1.14.0

package/native/csharp/StorageHelper/Pins.cs

@@ -0,0 +1,270 @@
+// The folders and the image of one data set, opened as handles and held for the whole call. Each handle is opened
+// without following links and without sharing delete, so while it is open nothing on the way can be renamed, deleted
+// or swapped for a link. Every handle is then checked: not a link, the path Windows reports is the exact path, on a
+// local fixed NTFS drive, and (for the user's own folders and the image) owned by the client with nobody else allowed
+// to change it. These are the checks of contained-common.ps1, done on handles instead of on names.
+using System;
+using System.Collections.Generic;
+using System.Security.AccessControl;
+using System.Security.Principal;
+using Microsoft.Win32.SafeHandles;
+
+namespace AgentSandbox.StorageHelper
+{
+    public sealed class Pins : IDisposable
+    {
+        private const uint LookAccess = Win32.ReadControl | Win32.FileReadAttributes | Win32.Synchronize;
+        private const uint Share = Win32.FileShareRead | Win32.FileShareWrite;
+        private const int WriteRights = 0x2 | 0x4 | 0x10 | 0x40 | 0x100 | 0x10000 | 0x40000 | 0x80000 | 0x10000000 | 0x40000000;
+        private static readonly string[] Trusted = { "S-1-5-18", "S-1-5-32-544", "S-1-3-0" };
+        private readonly List<SafeFileHandle> held = new List<SafeFileHandle>();
+        private readonly ContainedPaths paths;
+        private readonly SecurityIdentifier user;
+
+        private Pins(ContainedPaths paths, SecurityIdentifier user)
+        {
+            this.paths = paths;
+            this.user = user;
+        }
+
+        public SafeFileHandle Images { get; private set; }
+        public SafeFileHandle MountFolder { get; private set; }
+        public SafeFileHandle Image { get; private set; }
+        public bool MountIsMountPoint { get; private set; }
+        public Win32.ByHandleFileInformation ImageIdentity { get; private set; }
+
+        /// <summary>
+        /// Opens and checks everything from the drive root down to the mount folder. The mount folder is opened so it can
+        /// take a mount point. The image is opened when it exists.
+        /// </summary>
+        public static Pins Take(ContainedPaths paths, SecurityIdentifier user)
+        {
+            Pins pins = new Pins(paths, user);
+            try
+            {
+                pins.TakeAll();
+                return pins;
+            }
+            catch
+            {
+                pins.Dispose();
+                throw;
+            }
+        }
+
+        private void TakeAll()
+        {
+            string[] above = Rules.FoldersDownTo(paths.StorageRoot);
+            SafeFileHandle root = null;
+            for (int i = 0; i < above.Length; i++)
+            {
+                SafeFileHandle h = Folder(above[i], LookAccess, i == above.Length - 1 ? "The storage folder is missing: " : "A folder is missing: ");
+                if (i == 0)
+                {
+                    CheckDrive(h, above[0]);
+                }
+                root = h;
+            }
+            string volumeRoot = Win32.VolumePathOf(paths.StorageRoot + "\\");
+            if (volumeRoot.TrimEnd('\\').Length != 2)
+            {
+                throw new RefusedException("The storage folder is inside a mounted disk (" + Safe.Text(volumeRoot, 200) + "); contained storage cannot nest.");
+            }
+            CheckMine(root, paths.StorageRoot);
+            Images = Folder(paths.ImagesDir, LookAccess, "A folder is missing: ");
+            CheckMine(Images, paths.ImagesDir);
+            SafeFileHandle mounts = Folder(paths.MountsDir, LookAccess, "A folder is missing: ");
+            CheckMine(mounts, paths.MountsDir);
+            MountFolder = Open(paths.Mount, LookAccess | Win32.FileWriteAttributes | Win32.FileWriteData, true);
+            if (MountFolder == null)
+            {
+                throw new RefusedException("The mount folder is missing: " + paths.Mount);
+            }
+            Win32.ByHandleFileInformation mountInfo = Win32.InfoOf(MountFolder, paths.Mount);
+            if ((mountInfo.FileAttributes & Win32.AttributeDirectory) == 0)
+            {
+                throw new RefusedException("The mount folder is not a folder: " + paths.Mount);
+            }
+            MountIsMountPoint = (mountInfo.FileAttributes & Win32.AttributeReparsePoint) != 0;
+            CheckPath(MountFolder, paths.Mount);
+            CheckMine(MountFolder, paths.Mount);
+            Image = Open(paths.Image, LookAccess, false);
+            if (Image != null)
+            {
+                Win32.ByHandleFileInformation info = Win32.InfoOf(Image, paths.Image);
+                if ((info.FileAttributes & Win32.AttributeReparsePoint) != 0)
+                {
+                    throw new RefusedException("Refusing a link: " + paths.Image);
+                }
+                if ((info.FileAttributes & Win32.AttributeDirectory) != 0)
+                {
+                    throw new RefusedException("The image is not a file: " + paths.Image);
+                }
+                if (info.NumberOfLinks != 1)
+                {
+                    throw new RefusedException("The image has other names (hard links); refusing it: " + paths.Image);
+                }
+                CheckPath(Image, paths.Image);
+                CheckMine(Image, paths.Image);
+                ImageIdentity = info;
+            }
+            RecheckNoLinks();
+        }
+
+        /// <summary>
+        /// Every pinned folder is looked at again: a folder that was empty when it was checked could have become a link
+        /// before the folder below it was opened. Once all are pinned, none can (they are not empty, and cannot be renamed).
+        /// </summary>
+        private void RecheckNoLinks()
+        {
+            foreach (SafeFileHandle h in held)
+            {
+                if (h == MountFolder || h == Image)
+                {
+                    continue;
+                }
+                if ((Win32.InfoOf(h, "a folder").FileAttributes & Win32.AttributeReparsePoint) != 0)
+                {
+                    throw new RefusedException("A folder on the way became a link while it was being checked; nothing was done.");
+                }
+            }
+        }
+
+        /// <summary>True when the mount folder (pinned) is still a plain folder, not a link made after it was checked.</summary>
+        public bool MountFolderStillPlain()
+        {
+            return (Win32.InfoOf(MountFolder, paths.Mount).FileAttributes & Win32.AttributeReparsePoint) == 0;
+        }
+
+        /// <summary>Pins the image after this service made it (it did not exist when the folders were taken).</summary>
+        public void TakeNewImage()
+        {
+            Image = Open(paths.Image, LookAccess, false);
+            if (Image == null)
+            {
+                throw new InvalidOperationException("The new image is not there.");
+            }
+            CheckPath(Image, paths.Image);
+            ImageIdentity = Win32.InfoOf(Image, paths.Image);
+        }
+
+        /// <summary>True when the file at the image path is still the pinned one (same volume and file id).</summary>
+        public bool StillTheImage(SafeFileHandle other)
+        {
+            Win32.ByHandleFileInformation now = Win32.InfoOf(other, paths.Image);
+            return now.VolumeSerialNumber == ImageIdentity.VolumeSerialNumber && now.FileIndexHigh == ImageIdentity.FileIndexHigh && now.FileIndexLow == ImageIdentity.FileIndexLow;
+        }
+
+        private SafeFileHandle Folder(string path, uint access, string missing)
+        {
+            SafeFileHandle h = Open(path, access, true);
+            if (h == null)
+            {
+                throw new RefusedException(missing + path);
+            }
+            Win32.ByHandleFileInformation info = Win32.InfoOf(h, path);
+            if ((info.FileAttributes & Win32.AttributeReparsePoint) != 0)
+            {
+                throw new RefusedException(path.Length <= paths.StorageRoot.Length && !Rules.SamePath(path, paths.StorageRoot) ? "Refusing a link above the storage folder: " + path : "Refusing a link: " + path);
+            }
+            if ((info.FileAttributes & Win32.AttributeDirectory) == 0)
+            {
+                throw new RefusedException("Not a folder: " + path);
+            }
+            CheckPath(h, path);
+            return h;
+        }
+
+        private SafeFileHandle Open(string path, uint access, bool folder)
+        {
+            SafeFileHandle h = Win32.OpenNoFollow(path, access, Share);
+            if (h != null)
+            {
+                held.Add(h);
+            }
+            return h;
+        }
+
+        private static void CheckPath(SafeFileHandle h, string expected)
+        {
+            // A short 8.3 name (WDAGUT~1) comes back long; the long form of the expected path is accepted too.
+            if (!Win32.IsAt(h, expected))
+            {
+                throw new RefusedException("The folder is not where it says it is (a link on the way?): " + expected);
+            }
+        }
+
+        private static void CheckDrive(SafeFileHandle h, string driveRoot)
+        {
+            if (Win32.DriveTypeOf(driveRoot) != Win32.DriveFixed)
+            {
+                throw new RefusedException("Contained storage must be on a fixed local drive, not " + driveRoot);
+            }
+            string fs = Win32.FileSystemOf(h);
+            if (!string.Equals(fs, "NTFS", StringComparison.OrdinalIgnoreCase))
+            {
+                throw new RefusedException("Contained storage must be on an NTFS drive (" + driveRoot + " is " + Safe.Text(fs, 20) + ").");
+            }
+        }
+
+        /// <summary>Owned by the client, and nobody but the client, SYSTEM and Administrators may change or delete it.</summary>
+        private void CheckMine(SafeFileHandle h, string path)
+        {
+            RawSecurityDescriptor sd = Win32.SecurityOf(h);
+            if (sd.Owner == null || !sd.Owner.Equals(user))
+            {
+                throw new RefusedException("Not yours (owner " + (sd.Owner == null ? "none" : sd.Owner.Value) + "): " + path);
+            }
+            string other = OthersWhoMayChange(sd, user);
+            if (other != null)
+            {
+                throw new RefusedException("Someone else may change " + path + " (" + other + "); make it private first (sandbox repair).");
+            }
+        }
+
+        /// <summary>The first SID other than the user, SYSTEM, Administrators and CREATOR OWNER with a right to change, or null.</summary>
+        public static string OthersWhoMayChange(RawSecurityDescriptor sd, SecurityIdentifier user)
+        {
+            if (sd.DiscretionaryAcl == null)
+            {
+                return "Everyone (no permissions set)";
+            }
+            foreach (GenericAce ace in sd.DiscretionaryAcl)
+            {
+                if (ace.AceType == AceType.AccessDenied || ace.AceType == AceType.AccessDeniedObject || ace.AceType == AceType.AccessDeniedCallback || ace.AceType == AceType.AccessDeniedCallbackObject)
+                {
+                    continue;
+                }
+                KnownAce known = ace as KnownAce;
+                if (known == null)
+                {
+                    return "an entry of an unknown kind";
+                }
+                if (ace.AceType == AceType.SystemAudit || ace.AceType == AceType.SystemAlarm)
+                {
+                    continue;
+                }
+                if ((known.AccessMask & WriteRights) == 0)
+                {
+                    continue;
+                }
+                SecurityIdentifier sid = known.SecurityIdentifier;
+                if (sid.Equals(user) || Array.IndexOf(Trusted, sid.Value) >= 0)
+                {
+                    continue;
+                }
+                return sid.Value;
+            }
+            return null;
+        }
+
+        public void Dispose()
+        {
+            foreach (SafeFileHandle h in held)
+            {
+                h.Dispose();
+            }
+            held.Clear();
+        }
+    }
+}

package/native/csharp/StorageHelper/Privileges.cs

@@ -0,0 +1,78 @@
+// Turns on the privileges the service's own token holds but has switched off: managing volumes (attach, mount points),
+// restore (a new image's owner is the user, not the service) and backup. Only what the token already has; a missing
+// one is left out and the operation that needs it fails with Windows' own message.
+using System;
+using System.Runtime.InteropServices;
+
+namespace AgentSandbox.StorageHelper
+{
+    public static class Privileges
+    {
+        private const uint TokenAdjustPrivileges = 0x0020;
+        private const uint TokenQuery = 0x0008;
+        private const uint Enabled = 0x2;
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct Luid
+        {
+            public uint Low;
+            public int High;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct TokenPrivilege
+        {
+            public uint Count;
+            public Luid Luid;
+            public uint Attributes;
+        }
+
+        private static class NativeMethods
+        {
+            [DllImport("kernel32.dll")]
+            public static extern IntPtr GetCurrentProcess();
+
+            [DllImport("advapi32.dll", SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool OpenProcessToken(IntPtr process, uint access, out IntPtr token);
+
+            [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool LookupPrivilegeValueW(string system, string name, out Luid luid);
+
+            [DllImport("advapi32.dll", SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool AdjustTokenPrivileges(IntPtr token, [MarshalAs(UnmanagedType.Bool)] bool disableAll, ref TokenPrivilege state, uint length, IntPtr previous, IntPtr returned);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool CloseHandle(IntPtr handle);
+        }
+
+        public static void Enable(params string[] names)
+        {
+            IntPtr token;
+            if (!NativeMethods.OpenProcessToken(NativeMethods.GetCurrentProcess(), TokenAdjustPrivileges | TokenQuery, out token))
+            {
+                return;
+            }
+            try
+            {
+                foreach (string name in names)
+                {
+                    TokenPrivilege state = new TokenPrivilege();
+                    state.Count = 1;
+                    state.Attributes = Enabled;
+                    if (NativeMethods.LookupPrivilegeValueW(null, name, out state.Luid))
+                    {
+                        NativeMethods.AdjustTokenPrivileges(token, false, ref state, 0, IntPtr.Zero, IntPtr.Zero);
+                    }
+                }
+            }
+            finally
+            {
+                NativeMethods.CloseHandle(token);
+            }
+        }
+    }
+}

package/native/csharp/StorageHelper/Program.cs

@@ -0,0 +1,349 @@
+// AgentSandboxStorage.exe: the contained-storage helper of windows-development-sandbox.
+//   service --group <sid>        what Windows runs (the service AgentSandboxStorage, LocalSystem).
+//   console --pipe <name> --group <sid> --log-folder <dir> [--mutex <name>] [--machine-config <file>|none]
+//           [--profile <dir>] [--records <dir>] [--dry-run]
+//                                the same server in a console, for tests and a live check: it runs with the rights of
+//                                whoever starts it (so the test switches grant nothing) and stops when its input ends.
+//   check <mount|dismount> <storageRoot> <set> <userSid> <maxGb>
+//                                a dry run of the checks on one data set (no pipe, no disk is touched); prints the answer.
+//   derive <request.json>        Settings.Derive on {machine, user, base, profile, env}; prints {ok, root, maxGb}.
+//   parse                        Protocol.Parse on one line of input; prints {ok, verb, set}.
+//   release-all [--records <dir>] [--dry-run]
+//                                (administrators, when the helper is removed) dismounts every set the service mounted.
+// Exit code 0 = ok, 1 = refused or failed, 2 = wrong use.
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security.Principal;
+using System.ServiceProcess;
+using System.Text;
+using System.Web.Script.Serialization;
+
+namespace AgentSandbox.StorageHelper
+{
+    public static class Program
+    {
+        private const int ExitOk = 0;
+        private const int ExitFailed = 1;
+        private const int ExitUsage = 2;
+
+        public static int Main(string[] args)
+        {
+            if (args.Length == 0)
+            {
+                return Usage();
+            }
+            try
+            {
+                switch (args[0])
+                {
+                    case "service":
+                        return RunService(Options(args));
+                    case "console":
+                        return RunConsole(Options(args));
+                    case "check":
+                        return Check(args);
+                    case "derive":
+                        return Derive(args);
+                    case "parse":
+                        return Parse();
+                    case "release-all":
+                        return ReleaseAll(Options(args));
+                    case "version":
+                        Console.Out.WriteLine(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+                        return ExitOk;
+                    default:
+                        return Usage();
+                }
+            }
+            catch (ArgumentException e)
+            {
+                Console.Error.WriteLine("Usage: " + e.Message);
+                return ExitUsage;
+            }
+        }
+
+        private static int Usage()
+        {
+            Console.Error.WriteLine("Usage: AgentSandboxStorage.exe service|console|check|derive|parse|version (see the source header)");
+            return ExitUsage;
+        }
+
+        private static Dictionary<string, string> Options(string[] args)
+        {
+            Dictionary<string, string> options = new Dictionary<string, string>(StringComparer.Ordinal);
+            for (int i = 1; i < args.Length; i++)
+            {
+                if (args[i] == "--dry-run")
+                {
+                    options["--dry-run"] = "1";
+                }
+                else if (args[i].StartsWith("--", StringComparison.Ordinal) && i + 1 < args.Length)
+                {
+                    options[args[i]] = args[i + 1];
+                    i++;
+                }
+                else
+                {
+                    throw new ArgumentException("unknown option " + args[i]);
+                }
+            }
+            return options;
+        }
+
+        private static string Need(Dictionary<string, string> options, string name)
+        {
+            string value;
+            if (!options.TryGetValue(name, out value) || value.Length == 0)
+            {
+                throw new ArgumentException(name + " is needed");
+            }
+            return value;
+        }
+
+        private static SecurityIdentifier GroupOf(Dictionary<string, string> options)
+        {
+            try
+            {
+                return new SecurityIdentifier(Need(options, "--group"));
+            }
+            catch (ArgumentException)
+            {
+                throw new ArgumentException("--group needs a SID");
+            }
+        }
+
+        private static string MachineData()
+        {
+            return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "AgentSandbox");
+        }
+
+        /// <summary>Loads the DLLs the service calls before it ever acts as a client (nothing is loaded while it does).</summary>
+        private static void Warm()
+        {
+            Marshal.PrelinkAll(typeof(Win32.NativeMethods));
+            foreach (Type type in typeof(Program).Assembly.GetTypes())
+            {
+                if (type.Name == "NativeMethods")
+                {
+                    Marshal.PrelinkAll(type);
+                }
+            }
+            new JavaScriptSerializer().DeserializeObject("{\"a\":1}");
+        }
+
+        private static void PrepareProcess()
+        {
+            Warm();
+            Privileges.Enable("SeManageVolumePrivilege", "SeRestorePrivilege", "SeBackupPrivilege", "SeImpersonatePrivilege");
+        }
+
+        private static int RunService(Dictionary<string, string> options)
+        {
+            SecurityIdentifier group = GroupOf(options);
+            PrepareProcess();
+            string data = MachineData();
+            ServiceBase.Run(new StorageService(delegate()
+            {
+                ServerOptions o = new ServerOptions();
+                o.PipeName = Server.DefaultPipe;
+                o.MutexName = Server.DefaultMutex;
+                o.Group = group;
+                o.Log = Log.InFolder(Path.Combine(data, "logs"), true);
+                o.Sources = new SettingsSources();
+                o.Sources.MachineFile = Path.Combine(data, "config.json");
+                o.Records = new MountRecords(Path.Combine(data, "storage-helper"));
+                return new Server(o);
+            }));
+            return ExitOk;
+        }
+
+        private static int RunConsole(Dictionary<string, string> options)
+        {
+            PrepareProcess();
+            ServerOptions o = new ServerOptions();
+            o.PipeName = Need(options, "--pipe");
+            string mutex;
+            o.MutexName = options.TryGetValue("--mutex", out mutex) ? mutex : "Local\\AgentSandboxStorage-" + o.PipeName;
+            o.Group = GroupOf(options);
+            try
+            {
+                o.Log = Log.InFolder(Need(options, "--log-folder"), false);
+            }
+            catch (IOException e)
+            {
+                Console.Error.WriteLine(e.Message);
+                return ExitFailed;
+            }
+            o.Sources = new SettingsSources();
+            string machine;
+            o.Sources.MachineFile = options.TryGetValue("--machine-config", out machine) ? (machine == "none" ? null : machine) : Path.Combine(MachineData(), "config.json");
+            string profile;
+            if (options.TryGetValue("--profile", out profile))
+            {
+                o.Sources.ProfileOverride = profile;
+            }
+            o.DryRun = options.ContainsKey("--dry-run");
+            string records;
+            if (options.TryGetValue("--records", out records))
+            {
+                o.Records = new MountRecords(records);
+            }
+            using (Server server = new Server(o))
+            {
+                try
+                {
+                    server.Start();
+                }
+                catch (Exception e)
+                {
+                    Console.Error.WriteLine(e.Message);
+                    return ExitFailed;
+                }
+                Console.Out.WriteLine("ready");
+                Console.Out.Flush();
+                Console.In.ReadToEnd();
+            }
+            return ExitOk;
+        }
+
+        private static int ReleaseAll(Dictionary<string, string> options)
+        {
+            PrepareProcess();
+            string folder;
+            if (!options.TryGetValue("--records", out folder))
+            {
+                folder = Path.Combine(MachineData(), "storage-helper");
+            }
+            if (!Directory.Exists(folder))
+            {
+                Console.Out.WriteLine("nothing recorded");
+                return ExitOk;
+            }
+            MountRecords records = new MountRecords(folder);
+            bool dry = options.ContainsKey("--dry-run");
+            int failed = 0;
+            using (System.Threading.Mutex mutex = new System.Threading.Mutex(false, Server.DefaultMutex))
+            {
+                bool held;
+                try
+                {
+                    held = mutex.WaitOne(60000);
+                }
+                catch (System.Threading.AbandonedMutexException)
+                {
+                    held = true;
+                }
+                if (!held)
+                {
+                    Console.Error.WriteLine("Another mount or dismount is running. Try again in a minute.");
+                    return ExitFailed;
+                }
+                try
+                {
+                    foreach (MountRecord record in records.Read())
+                    {
+                        Request request = Server.RecordRequest(record);
+                        request.DryRun = dry;
+                        Outcome outcome = Operations.Run(request);
+                        Console.Out.WriteLine(record.Set + " (" + record.StorageRoot + "): " + (outcome.Ok ? "" : "refused: ") + outcome.Message);
+                        if (outcome.Ok && !dry)
+                        {
+                            records.Remove(record);
+                        }
+                        if (!outcome.Ok)
+                        {
+                            failed++;
+                        }
+                    }
+                }
+                finally
+                {
+                    mutex.ReleaseMutex();
+                }
+            }
+            return failed == 0 ? ExitOk : ExitFailed;
+        }
+
+        private static int Check(string[] args)
+        {
+            if (args.Length != 6)
+            {
+                throw new ArgumentException("check <mount|dismount> <storageRoot> <set> <userSid> <maxGb>");
+            }
+            long maxGb;
+            if (!long.TryParse(args[5], out maxGb))
+            {
+                throw new ArgumentException("maxGb must be a number");
+            }
+            Request request = new Request();
+            request.Verb = args[1];
+            request.Set = args[3];
+            request.User = new SecurityIdentifier(args[4]);
+            request.Settings = new StorageSettings(args[2], maxGb);
+            request.DryRun = true;
+            Outcome outcome = Operations.Run(request);
+            Console.Out.WriteLine(Protocol.Answer(outcome));
+            return outcome.Ok ? ExitOk : ExitFailed;
+        }
+
+        private static int Derive(string[] args)
+        {
+            if (args.Length != 2)
+            {
+                throw new ArgumentException("derive <request.json>");
+            }
+            Dictionary<string, object> input = new JavaScriptSerializer().DeserializeObject(File.ReadAllText(args[1], Encoding.UTF8)) as Dictionary<string, object>;
+            if (input == null)
+            {
+                throw new ArgumentException("the request must be a JSON object");
+            }
+            Dictionary<string, string> environment = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            object env;
+            if (input.TryGetValue("env", out env) && env is Dictionary<string, object>)
+            {
+                foreach (KeyValuePair<string, object> pair in (Dictionary<string, object>)env)
+                {
+                    environment[pair.Key] = pair.Value as string ?? "";
+                }
+            }
+            try
+            {
+                StorageSettings s = Settings.Derive(Text(input, "machine"), Text(input, "user"), Text(input, "base"), Text(input, "profile"), environment);
+                Console.Out.WriteLine("{\"ok\":true,\"root\":" + Protocol.Quote(s.StorageRoot) + ",\"maxGb\":" + s.MaxGb + "}");
+                return ExitOk;
+            }
+            catch (RefusedException e)
+            {
+                Console.Out.WriteLine("{\"ok\":false,\"message\":" + Protocol.Quote(e.Message) + "}");
+                return ExitFailed;
+            }
+        }
+
+        private static string Text(Dictionary<string, object> input, string key)
+        {
+            object value;
+            return input.TryGetValue(key, out value) ? value as string : null;
+        }
+
+        private static int Parse()
+        {
+            string line = Console.In.ReadLine();
+            try
+            {
+                string verb;
+                string set;
+                Protocol.Parse(line, out verb, out set);
+                Console.Out.WriteLine("{\"ok\":true,\"verb\":" + Protocol.Quote(verb) + ",\"set\":" + Protocol.Quote(set) + "}");
+                return ExitOk;
+            }
+            catch (RefusedException e)
+            {
+                Console.Out.WriteLine("{\"ok\":false,\"message\":" + Protocol.Quote(e.Message) + "}");
+                return ExitFailed;
+            }
+        }
+    }
+}