windows-development-sandbox 1.13.2 → 1.14.0

package/native/csharp/StorageHelper/Vhdx.cs

@@ -0,0 +1,230 @@
+// Reads the VHDX header of an image through a stream the caller opened (the layout is in the VHDX specification), the
+// same reading as Read-VhdxInfo in native\scripts\contained-common.ps1: is it a VHDX, how big may it grow, does it have
+// a parent (a differencing disk would reach into another file)? It also reads the current header (the valid one with
+// the higher sequence number, checksum CRC-32C) to see whether it names a log the disk driver would replay.
+using System;
+using System.IO;
+using System.Text;
+
+namespace AgentSandbox.StorageHelper
+{
+    public sealed class VhdxInfo
+    {
+        public VhdxInfo(ulong virtualSize, bool hasParent, bool hasLog)
+        {
+            VirtualSize = virtualSize;
+            HasParent = hasParent;
+            HasLog = hasLog;
+        }
+
+        public ulong VirtualSize { get; private set; }
+        public bool HasParent { get; private set; }
+
+        /// <summary>The current header names a log to replay (the image was not closed cleanly, or the log was written by hand).</summary>
+        public bool HasLog { get; private set; }
+    }
+
+    public static class Vhdx
+    {
+        private const long RegionTableOffset = 196608;
+        private const long Header1Offset = 65536;
+        private const long Header2Offset = 131072;
+        private const int HeaderBytes = 4096;
+        private const int TableBytes = 65536;
+        private const int MaxRegions = 64;
+        private const int MaxMetadataItems = 2047;
+        private static readonly Guid MetadataRegion = new Guid("8b7ca206-4790-4b9a-b8fe-575f050f886e");
+        private static readonly Guid VirtualSizeItem = new Guid("2fa54224-cd1b-4876-b211-5dbed83bf4b8");
+        private static readonly Guid ParentItem = new Guid("a8d35f2d-b30b-454d-abf7-d3d84834ab0c");
+
+        public static VhdxInfo Read(Stream stream)
+        {
+            if (Encoding.ASCII.GetString(ReadExact(stream, 0, 8)) != "vhdxfile")
+            {
+                throw new RefusedException("The file is not a VHDX image.");
+            }
+            byte[] table = ReadExact(stream, RegionTableOffset, TableBytes);
+            if (Encoding.ASCII.GetString(table, 0, 4) != "regi")
+            {
+                throw new RefusedException("The image has no region table.");
+            }
+            uint count = BitConverter.ToUInt32(table, 8);
+            if (count > MaxRegions)
+            {
+                throw new RefusedException("The image has too many regions.");
+            }
+            long metadataOffset = -1;
+            for (int i = 0; i < count; i++)
+            {
+                int at = 16 + 32 * i;
+                if (GuidAt(table, at) == MetadataRegion)
+                {
+                    ulong offset = BitConverter.ToUInt64(table, at + 16);
+                    if (offset > long.MaxValue)
+                    {
+                        throw new RefusedException("The image is not a valid VHDX file (a part is missing).");
+                    }
+                    metadataOffset = (long)offset;
+                }
+            }
+            if (metadataOffset < 0)
+            {
+                throw new RefusedException("The image has no metadata region.");
+            }
+            byte[] meta = ReadExact(stream, metadataOffset, TableBytes);
+            if (Encoding.ASCII.GetString(meta, 0, 8) != "metadata")
+            {
+                throw new RefusedException("The image has no metadata table.");
+            }
+            int items = BitConverter.ToUInt16(meta, 10);
+            if (items > MaxMetadataItems)
+            {
+                throw new RefusedException("The image has too many metadata items.");
+            }
+            ulong size = 0;
+            bool hasParent = false;
+            for (int i = 0; i < items; i++)
+            {
+                int at = 32 + 32 * i;
+                Guid id = GuidAt(meta, at);
+                if (id == ParentItem)
+                {
+                    hasParent = true;
+                }
+                if (id == VirtualSizeItem)
+                {
+                    long itemOffset = BitConverter.ToUInt32(meta, at + 16);
+                    size = BitConverter.ToUInt64(ReadExact(stream, metadataOffset + itemOffset, 8), 0);
+                }
+            }
+            return new VhdxInfo(size, hasParent, CurrentHeaderHasLog(stream));
+        }
+
+        private static bool CurrentHeaderHasLog(Stream stream)
+        {
+            byte[] best = null;
+            ulong bestSequence = 0;
+            foreach (long offset in new long[] { Header1Offset, Header2Offset })
+            {
+                byte[] header = ReadExact(stream, offset, HeaderBytes);
+                if (Encoding.ASCII.GetString(header, 0, 4) != "head" || !ChecksumOk(header))
+                {
+                    continue;
+                }
+                ulong sequence = BitConverter.ToUInt64(header, 8);
+                if (best == null || sequence > bestSequence)
+                {
+                    best = header;
+                    bestSequence = sequence;
+                }
+            }
+            if (best == null)
+            {
+                throw new RefusedException("The image has no valid header.");
+            }
+            for (int i = 48; i < 64; i++)
+            {
+                if (best[i] != 0)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private static bool ChecksumOk(byte[] header)
+        {
+            uint stored = BitConverter.ToUInt32(header, 4);
+            byte[] copy = (byte[])header.Clone();
+            copy[4] = 0;
+            copy[5] = 0;
+            copy[6] = 0;
+            copy[7] = 0;
+            return Crc32C(copy) == stored;
+        }
+
+        private static uint[] crcTable;
+
+        public static uint Crc32C(byte[] data)
+        {
+            uint[] table = crcTable;
+            if (table == null)
+            {
+                table = new uint[256];
+                for (uint i = 0; i < 256; i++)
+                {
+                    uint c = i;
+                    for (int k = 0; k < 8; k++)
+                    {
+                        c = (c & 1) != 0 ? 0x82F63B78u ^ (c >> 1) : c >> 1;
+                    }
+                    table[i] = c;
+                }
+                crcTable = table;
+            }
+            uint crc = 0xFFFFFFFFu;
+            foreach (byte b in data)
+            {
+                crc = table[(crc ^ b) & 0xFF] ^ (crc >> 8);
+            }
+            return crc ^ 0xFFFFFFFFu;
+        }
+
+        /// <summary>Refuses a differencing disk, an unreadable size and one bigger than the limit.</summary>
+        public static void CheckPlain(VhdxInfo info, long maxGb)
+        {
+            if (info.HasParent)
+            {
+                throw new RefusedException("The image is a differencing disk (it has a parent file); refusing it.");
+            }
+            if (info.HasLog)
+            {
+                throw new LogPendingException();
+            }
+            if (info.VirtualSize == 0)
+            {
+                throw new RefusedException("The image size could not be read.");
+            }
+            if (info.VirtualSize > (ulong)maxGb * 1024UL * 1024UL * 1024UL)
+            {
+                throw new RefusedException("The image is bigger than the limit of " + maxGb + " GB.");
+            }
+        }
+
+        private static Guid GuidAt(byte[] bytes, int offset)
+        {
+            byte[] part = new byte[16];
+            Array.Copy(bytes, offset, part, 0, 16);
+            return new Guid(part);
+        }
+
+        private static byte[] ReadExact(Stream stream, long offset, int count)
+        {
+            if (offset < 0 || offset > stream.Length - count)
+            {
+                throw new RefusedException("The image is not a valid VHDX file (a part is missing).");
+            }
+            stream.Seek(offset, SeekOrigin.Begin);
+            byte[] buffer = new byte[count];
+            int done = 0;
+            while (done < count)
+            {
+                int n = stream.Read(buffer, done, count - done);
+                if (n <= 0)
+                {
+                    throw new RefusedException("The image could not be read.");
+                }
+                done += n;
+            }
+            return buffer;
+        }
+    }
+
+    /// <summary>The image names a log to replay: this service does not let the disk driver replay it (the UAC path may).</summary>
+    public sealed class LogPendingException : Exception
+    {
+        public LogPendingException() : base("The image was not closed cleanly (its log has changes to replay), so the helper leaves it to the Windows permission prompt.")
+        {
+        }
+    }
+}

package/native/csharp/StorageHelper/VirtualDisk.cs

@@ -0,0 +1,241 @@
+// One VHDX through virtdisk.dll, held by its handle from the open to the attach: open it (never its parents), ask the
+// disk driver what it is (VHDX, not a differencing disk, its size), attach it without drive letters for good (until a
+// detach or a restart), detach it. A new image is made with CreateVirtualDisk, which refuses a file that exists, with
+// the user as its owner. Signatures from the Microsoft virtdisk.h reference.
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace AgentSandbox.StorageHelper
+{
+    public sealed class VirtualDisk : IDisposable
+    {
+        private const uint DeviceVhdx = 3;
+        private static readonly Guid VendorMicrosoft = new Guid("EC984AEC-A0F9-47e9-901F-71415A66345B");
+        private const uint AccessAttachRw = 0x00020000;
+        private const uint AccessDetach = 0x00040000;
+        private const uint AccessGetInfo = 0x00080000;
+        private const uint AccessAll = 0x003f0000;
+        private const uint OpenFlagNoParents = 0x1;
+        private const uint OpenVersion1 = 1;
+        private const uint CreateVersion1 = 1;
+        private const uint AttachVersion1 = 1;
+        private const uint AttachNoDriveLetter = 0x2;
+        private const uint AttachPermanentLifetime = 0x4;
+        private const uint InfoSize = 1;
+        private const uint InfoStorageType = 6;
+        private const uint InfoProviderSubtype = 7;
+        private const uint SubtypeDifferencing = 4;
+        private const int ErrorFileExists = 80;
+        private const int ErrorAlreadyExists = 183;
+        private const int ErrorNotReady = 21;
+        private const int ErrorDevNotExist = 55;
+        private const int ErrorVirtualDiskNotAttached = unchecked((int)0xC03A0015);
+
+        private IntPtr handle;
+
+        private VirtualDisk(IntPtr handle)
+        {
+            this.handle = handle;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct StorageType
+        {
+            public uint DeviceId;
+            public Guid VendorId;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct OpenParametersV1
+        {
+            public uint Version;
+            public uint RwDepth;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct CreateParametersV1
+        {
+            public uint Version;
+            public Guid UniqueId;
+            public ulong MaximumSize;
+            public uint BlockSizeInBytes;
+            public uint SectorSizeInBytes;
+            public IntPtr ParentPath;
+            public IntPtr SourcePath;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct AttachParametersV1
+        {
+            public uint Version;
+            public uint Reserved;
+        }
+
+        private static class NativeMethods
+        {
+            [DllImport("virtdisk.dll", CharSet = CharSet.Unicode)]
+            public static extern int OpenVirtualDisk(ref StorageType storageType, string path, uint accessMask, uint flags, ref OpenParametersV1 parameters, out IntPtr handle);
+
+            [DllImport("virtdisk.dll", CharSet = CharSet.Unicode)]
+            public static extern int CreateVirtualDisk(ref StorageType storageType, string path, uint accessMask, byte[] securityDescriptor, uint flags, uint providerSpecificFlags, ref CreateParametersV1 parameters, IntPtr overlapped, out IntPtr handle);
+
+            [DllImport("virtdisk.dll")]
+            public static extern int AttachVirtualDisk(IntPtr handle, IntPtr securityDescriptor, uint flags, uint providerSpecificFlags, ref AttachParametersV1 parameters, IntPtr overlapped);
+
+            [DllImport("virtdisk.dll")]
+            public static extern int DetachVirtualDisk(IntPtr handle, uint flags, uint providerSpecificFlags);
+
+            [DllImport("virtdisk.dll")]
+            public static extern int GetVirtualDiskInformation(IntPtr handle, ref uint size, byte[] info, IntPtr used);
+
+            [DllImport("virtdisk.dll", CharSet = CharSet.Unicode)]
+            public static extern int GetVirtualDiskPhysicalPath(IntPtr handle, ref uint size, StringBuilder path);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool CloseHandle(IntPtr handle);
+        }
+
+        private static StorageType Vhdx()
+        {
+            StorageType type = new StorageType();
+            type.DeviceId = DeviceVhdx;
+            type.VendorId = VendorMicrosoft;
+            return type;
+        }
+
+        /// <summary>Opens an existing VHDX for attach, detach and questions; its parents (if any) are never opened.</summary>
+        public static VirtualDisk Open(string path)
+        {
+            StorageType type = Vhdx();
+            OpenParametersV1 parameters = new OpenParametersV1();
+            parameters.Version = OpenVersion1;
+            parameters.RwDepth = 1;
+            IntPtr h;
+            int error = NativeMethods.OpenVirtualDisk(ref type, path, AccessAttachRw | AccessDetach | AccessGetInfo, OpenFlagNoParents, ref parameters, out h);
+            if (error != 0)
+            {
+                throw new Win32Exception(error, "Could not open the image: " + new Win32Exception(error).Message);
+            }
+            return new VirtualDisk(h);
+        }
+
+        /// <summary>Makes a new dynamic VHDX (refused when any file is there) with this security descriptor, and keeps it open.</summary>
+        public static VirtualDisk Create(string path, long maxGb, byte[] securityDescriptor)
+        {
+            StorageType type = Vhdx();
+            CreateParametersV1 parameters = new CreateParametersV1();
+            parameters.Version = CreateVersion1;
+            parameters.MaximumSize = (ulong)maxGb * 1024UL * 1024UL * 1024UL;
+            IntPtr h;
+            int error = NativeMethods.CreateVirtualDisk(ref type, path, AccessAll, securityDescriptor, 0, 0, ref parameters, IntPtr.Zero, out h);
+            if (error == ErrorFileExists || error == ErrorAlreadyExists)
+            {
+                throw new RefusedException("An image exists already; refusing to create over it: " + path);
+            }
+            if (error != 0)
+            {
+                throw new Win32Exception(error, "Could not create the image: " + new Win32Exception(error).Message);
+            }
+            return new VirtualDisk(h);
+        }
+
+        /// <summary>What the disk driver says: a VHDX, not a differencing disk (provider subtype 4), its size.</summary>
+        public void CheckPlain(long maxGb)
+        {
+            byte[] type = Info(InfoStorageType);
+            if (BitConverter.ToUInt32(type, 8) != DeviceVhdx)
+            {
+                throw new RefusedException("The image is not a VHDX disk.");
+            }
+            if (BitConverter.ToUInt32(Info(InfoProviderSubtype), 8) == SubtypeDifferencing)
+            {
+                throw new RefusedException("The image is a differencing disk (it has a parent file); refusing it.");
+            }
+            ulong size = BitConverter.ToUInt64(Info(InfoSize), 8);
+            if (size == 0 || size > (ulong)maxGb * 1024UL * 1024UL * 1024UL)
+            {
+                throw new RefusedException("The image is bigger than the limit of " + maxGb + " GB.");
+            }
+        }
+
+        private byte[] Info(uint version)
+        {
+            byte[] buffer = new byte[1024];
+            BitConverter.GetBytes(version).CopyTo(buffer, 0);
+            uint size = (uint)buffer.Length;
+            int error = NativeMethods.GetVirtualDiskInformation(handle, ref size, buffer, IntPtr.Zero);
+            if (error != 0)
+            {
+                throw new Win32Exception(error, "Could not read the image's details: " + new Win32Exception(error).Message);
+            }
+            return buffer;
+        }
+
+        /// <summary>\\.\PhysicalDriveN while attached; null when it is not attached.</summary>
+        public string PhysicalPath()
+        {
+            StringBuilder sb = new StringBuilder(260);
+            uint size = (uint)(sb.Capacity * 2);
+            int error = NativeMethods.GetVirtualDiskPhysicalPath(handle, ref size, sb);
+            if (error == 0)
+            {
+                return sb.ToString();
+            }
+            if (error == ErrorVirtualDiskNotAttached || error == ErrorNotReady || error == ErrorDevNotExist || (error & 0xFFFF) == 0x15)
+            {
+                return null;
+            }
+            throw new Win32Exception(error, "Could not tell whether the image is attached: " + new Win32Exception(error).Message);
+        }
+
+        /// <summary>The disk number of an attached image (from \\.\PhysicalDriveN), or -1.</summary>
+        public int DiskNumber()
+        {
+            string path = PhysicalPath();
+            if (path == null)
+            {
+                return -1;
+            }
+            const string Prefix = "\\\\.\\PhysicalDrive";
+            int number;
+            if (!path.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase) || !int.TryParse(path.Substring(Prefix.Length), out number))
+            {
+                throw new InvalidOperationException("Unexpected disk path: " + Safe.Text(path, 100));
+            }
+            return number;
+        }
+
+        /// <summary>Attaches until a detach or a restart (not only while this handle is open), with no drive letters.</summary>
+        public void Attach()
+        {
+            AttachParametersV1 parameters = new AttachParametersV1();
+            parameters.Version = AttachVersion1;
+            int error = NativeMethods.AttachVirtualDisk(handle, IntPtr.Zero, AttachNoDriveLetter | AttachPermanentLifetime, 0, ref parameters, IntPtr.Zero);
+            if (error != 0)
+            {
+                throw new Win32Exception(error, "Could not attach the image: " + new Win32Exception(error).Message);
+            }
+        }
+
+        public void Detach()
+        {
+            int error = NativeMethods.DetachVirtualDisk(handle, 0, 0);
+            if (error != 0)
+            {
+                throw new Win32Exception(error, "Could not detach the image (something may still use files in it): " + new Win32Exception(error).Message);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (handle != IntPtr.Zero && handle != new IntPtr(-1))
+            {
+                NativeMethods.CloseHandle(handle);
+            }
+            handle = IntPtr.Zero;
+        }
+    }
+}