Updated DiskAccessLibrary

DiskAccessLibrary/DiskAccessLibrary.csproj

@@ -43,6 +43,7 @@
     <Compile Include="Disks\VHD\ParentLocatorEntry.cs" />
     <Compile Include="Disks\VHD\VHDFooter.cs" />
     <Compile Include="Disks\VHD\VirtualHardDisk.cs" />
+    <Compile Include="Disks\VHD\VirtualHardDisk.Dynamic.cs" />
     <Compile Include="Disks\VHD\VirtualHardDiskType.cs" />
     <Compile Include="Disks\VMDK\ExtentType.cs" />
     <Compile Include="Disks\VMDK\SparseExtent.cs" />

DiskAccessLibrary/Disks/VHD/BlockAllocationTable.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014-2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -17,34 +17,34 @@ namespace DiskAccessLibrary.VHD
     public class BlockAllocationTable
     {
         public const uint UnusedEntry = 0xFFFFFFFF;
-        public uint[] Entries;
+        private uint[] m_entries;
 
         public BlockAllocationTable(uint maxTableEntries)
         {
-            Entries = new uint[maxTableEntries];
+            m_entries = new uint[maxTableEntries];
             for (int index = 0; index < maxTableEntries; index++)
             {
-                Entries[index] = UnusedEntry;
+                m_entries[index] = UnusedEntry;
             }
         }
 
         public BlockAllocationTable(byte[] buffer, uint maxTableEntries)
         { 
-            Entries = new uint[maxTableEntries];
+            m_entries = new uint[maxTableEntries];
             for (int index = 0; index < maxTableEntries; index++)
             {
-                Entries[index] = BigEndianConverter.ToUInt32(buffer, index * 4);
+                m_entries[index] = BigEndianConverter.ToUInt32(buffer, index * 4);
             }
         }
 
         public byte[] GetBytes()
         {
             // The BAT is always extended to a sector boundary
-            int bufferLength = (int)Math.Ceiling((double)Entries.Length * 4 / VirtualHardDisk.BytesPerDiskSector) * VirtualHardDisk.BytesPerDiskSector;
+            int bufferLength = (int)Math.Ceiling((double)m_entries.Length * 4 / VirtualHardDisk.BytesPerDiskSector) * VirtualHardDisk.BytesPerDiskSector;
             byte[] buffer = new byte[bufferLength];
-            for (int index = 0; index < Entries.Length; index++)
+            for (int index = 0; index < m_entries.Length; index++)
             {
-                BigEndianWriter.WriteUInt32(buffer, index * 4, Entries[index]);
+                BigEndianWriter.WriteUInt32(buffer, index * 4, m_entries[index]);
             }
 
             return buffer;
@@ -52,7 +52,23 @@ namespace DiskAccessLibrary.VHD
 
         public bool IsBlockInUse(uint blockIndex)
         {
-            return Entries[blockIndex] != UnusedEntry;
+            return m_entries[blockIndex] != UnusedEntry;
+        }
+
+        public bool IsBlockInUse(uint blockIndex, out uint blockStartSector)
+        {
+            blockStartSector = m_entries[blockIndex];
+            return m_entries[blockIndex] != UnusedEntry;
+        }
+
+        public void SetBlockStartSector(uint blockIndex, uint blockStartSector)
+        {
+            if (m_entries[blockIndex] != UnusedEntry)
+            {
+                throw new InvalidOperationException("Block is already allocated");
+            }
+
+            m_entries[blockIndex] = blockStartSector;
         }
 
         public static BlockAllocationTable ReadBlockAllocationTable(string path, DynamicDiskHeader dynamicHeader)

DiskAccessLibrary/Disks/VHD/DynamicDiskHeader.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -43,6 +43,14 @@ namespace DiskAccessLibrary.VHD
             Cookie = DynamidDiskHeaderCookie;
             DataOffset = 0xFFFFFFFFFFFFFFFF;
             HeaderVersion = 0x00010000;
+            ParentLocatorEntry1 = new ParentLocatorEntry();
+            ParentLocatorEntry2 = new ParentLocatorEntry();
+            ParentLocatorEntry3 = new ParentLocatorEntry();
+            ParentLocatorEntry4 = new ParentLocatorEntry();
+            ParentLocatorEntry5 = new ParentLocatorEntry();
+            ParentLocatorEntry6 = new ParentLocatorEntry();
+            ParentLocatorEntry7 = new ParentLocatorEntry();
+            ParentLocatorEntry8 = new ParentLocatorEntry();
         }
 
         public DynamicDiskHeader(byte[] buffer)

DiskAccessLibrary/Disks/VHD/VirtualHardDisk.Dynamic.cs

@@ -0,0 +1,216 @@
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+ * 
+ * You can redistribute this program and/or modify it under the terms of
+ * the GNU Lesser Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ */
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Utilities;
+using DiskAccessLibrary.VHD;
+
+namespace DiskAccessLibrary
+{
+    public partial class VirtualHardDisk
+    {
+        private byte[] ReadSectorsFromDynamicDisk(long sectorIndex, int sectorCount)
+        {
+            byte[] buffer = new byte[sectorCount * BytesPerDiskSector];
+            int sectorOffset = 0;
+            while (sectorOffset < sectorCount)
+            {
+                uint blockIndex = (uint)((sectorIndex + sectorOffset) * BytesPerDiskSector / m_dynamicHeader.BlockSize);
+                int sectorOffsetInBlock = (int)(((sectorIndex + sectorOffset) * BytesPerDiskSector % m_dynamicHeader.BlockSize) / BytesPerDiskSector);
+                int sectorsInBlock = (int)(m_dynamicHeader.BlockSize / BytesPerDiskSector);
+                int sectorsRemainingInBlock = sectorsInBlock - sectorOffsetInBlock;
+                int sectorsToRead = Math.Min(sectorCount - sectorOffset, sectorsRemainingInBlock);
+
+                uint blockStartSector;
+                if (m_blockAllocationTable.IsBlockInUse(blockIndex, out blockStartSector))
+                {
+                    // Each data block has a sector bitmap preceding the data, the bitmap is padded to a 512-byte sector boundary.
+                    int blockBitmapSectorCount = (int)Math.Ceiling((double)sectorsInBlock / (BytesPerDiskSector * 8));
+                    // "All sectors within a block whose corresponding bits in the bitmap are zero must contain 512 bytes of zero on disk"
+                    byte[] temp = m_file.ReadSectors(blockStartSector + blockBitmapSectorCount + sectorOffsetInBlock, sectorsToRead);
+                    ByteWriter.WriteBytes(buffer, sectorOffset * BytesPerDiskSector, temp);
+                }
+                sectorOffset += sectorsToRead;
+            }
+            return buffer;
+        }
+
+        private byte[] ReadBlockUsageBitmap(uint blockIndex)
+        {
+            if (m_vhdFooter.DiskType != VirtualHardDiskType.Fixed)
+            {
+                uint blockStartSector;
+                int sectorsInBlock = (int)(m_dynamicHeader.BlockSize / BytesPerDiskSector);
+                // Each data block has a sector bitmap preceding the data, the bitmap is padded to a 512-byte sector boundary.
+                int blockBitmapSectorCount = (int)Math.Ceiling((double)sectorsInBlock / (BytesPerDiskSector * 8));
+                if (m_blockAllocationTable.IsBlockInUse(blockIndex, out blockStartSector))
+                {
+                    byte[] bitmap = m_file.ReadSectors(blockStartSector, blockBitmapSectorCount);
+                    return bitmap;
+                }
+                else
+                {
+                    return new byte[blockBitmapSectorCount * BytesPerDiskSector];
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Fixed VHDs do not have a Block Usage Bitmap");
+            }
+        }
+
+        private void WriteSectorsToDynamicDisk(long sectorIndex, byte[] data)
+        {
+            int sectorOffset = 0;
+            int sectorCount = data.Length / BytesPerDiskSector;
+            while (sectorOffset < sectorCount)
+            {
+                uint blockIndex = (uint)((sectorIndex + sectorOffset) * BytesPerDiskSector / m_dynamicHeader.BlockSize);
+                int sectorOffsetInBlock = (int)(((sectorIndex + sectorOffset) * BytesPerDiskSector % m_dynamicHeader.BlockSize) / BytesPerDiskSector);
+                int sectorsInBlock = (int)(m_dynamicHeader.BlockSize / BytesPerDiskSector);
+                int sectorsRemainingInBlock = sectorsInBlock - sectorOffsetInBlock;
+                int sectorsToWrite = Math.Min(sectorCount - sectorOffset, sectorsRemainingInBlock);
+
+                uint blockStartSector;
+                if (!m_blockAllocationTable.IsBlockInUse(blockIndex, out blockStartSector))
+                {
+                    blockStartSector = AllocateDynamicDiskBlock(blockIndex);
+                }
+
+                // Each data block has a sector bitmap preceding the data, the bitmap is padded to a 512-byte sector boundary.
+                int blockBitmapSectorCount = (int)Math.Ceiling((double)sectorsInBlock / (BytesPerDiskSector * 8));
+                // "All sectors within a block whose corresponding bits in the bitmap are zero must contain 512 bytes of zero on disk"
+                int blockBitmapSectorOffset = sectorOffsetInBlock / (BytesPerDiskSector * 8);
+                int sectorOffsetInBitmap = sectorOffsetInBlock % (BytesPerDiskSector * 8);
+                int remainingInBitmapSector = (BytesPerDiskSector * 8) - sectorOffsetInBitmap;
+                int blockBitmapSectorsToUpdate = 1;
+                if (sectorsToWrite > remainingInBitmapSector)
+                {
+                    blockBitmapSectorsToUpdate = (int)Math.Ceiling((double)(sectorsToWrite - remainingInBitmapSector) / (BytesPerDiskSector * 8));
+                }
+
+                byte[] bitmap = m_file.ReadSectors(blockStartSector + blockBitmapSectorOffset, blockBitmapSectorsToUpdate);
+                UpdateBlockUsageBitmap(bitmap, sectorOffsetInBitmap, sectorsToWrite, true);
+                m_file.WriteSectors(blockStartSector + blockBitmapSectorOffset, bitmap);
+                byte[] temp = ByteReader.ReadBytes(data, sectorOffset * BytesPerDiskSector, sectorsToWrite * BytesPerDiskSector);
+                m_file.WriteSectors(blockStartSector + blockBitmapSectorCount + sectorOffsetInBlock, temp);
+
+                sectorOffset += sectorsToWrite;
+            }
+        }
+
+        /// <returns>Block start sector</returns>
+        private uint AllocateDynamicDiskBlock(uint blockIndex)
+        {
+            long footerOffset = m_file.Size - VHDFooter.Length;
+            uint blockStartSector = (uint)(footerOffset / BytesPerDiskSector);
+            int sectorsInBlock = (int)(m_dynamicHeader.BlockSize / BytesPerDiskSector);
+            // Each data block has a sector bitmap preceding the data, the bitmap is padded to a 512-byte sector boundary.
+            int blockBitmapSectorCount = (int)Math.Ceiling((double)sectorsInBlock / (BytesPerDiskSector * 8));
+            // Block Size does not include the size of the block bitmap.
+            ExtendFile(blockBitmapSectorCount * BytesPerDiskSector + m_dynamicHeader.BlockSize);
+            byte[] bitmap = new byte[blockBitmapSectorCount * BytesPerDiskSector];
+            m_file.WriteSectors(blockStartSector, bitmap);
+            // All sectors within a block whose corresponding bits in the bitmap are zero must contain 512 bytes of zero on disk.
+            byte[] blockSectors = new byte[sectorsInBlock * BytesPerDiskSector];
+            m_file.WriteSectors(blockStartSector + blockBitmapSectorCount, blockSectors);
+
+            // Update the Block Allocation Table
+            m_blockAllocationTable.SetBlockStartSector(blockIndex, blockStartSector);
+            byte[] blockAllocationTableBytes = m_blockAllocationTable.GetBytes();
+            long blockAllocationTableSectorIndex = (long)(m_dynamicHeader.TableOffset / VirtualHardDisk.BytesPerDiskSector);
+            m_file.WriteSectors(blockAllocationTableSectorIndex, blockAllocationTableBytes);
+
+            return blockStartSector;
+        }
+
+        public void AllocateAllDynamicDiskBlocks()
+        {
+            if (m_vhdFooter.DiskType != VirtualHardDiskType.Fixed)
+            {
+                for (uint blockIndex = 0; blockIndex < m_dynamicHeader.MaxTableEntries; blockIndex++)
+                {
+                    if (!m_blockAllocationTable.IsBlockInUse(blockIndex))
+                    {
+                        AllocateDynamicDiskBlock(blockIndex);
+                    }
+                }
+            }
+        }
+
+        private static bool IsSectorInUse(byte[] bitmap, int sectorOffsetInBitmap)
+        {
+            int byteOffset = sectorOffsetInBitmap / 8;
+            int bitOffset = 7 - sectorOffsetInBitmap % 8;
+            bool isUsed = (bitmap[byteOffset] & (byte)(0x01 << bitOffset)) > 0;
+            return isUsed;
+        }
+
+        private static void UpdateBlockUsageBitmap(byte[] bitmap, int sectorOffsetInBitmap, int sectorCount, bool isUsed)
+        {
+            for (int offsetInBitmap = 0; offsetInBitmap < sectorCount; offsetInBitmap++)
+            {
+                UpdateBlockUsageBitmap(bitmap, sectorOffsetInBitmap + offsetInBitmap, isUsed);
+            }
+        }
+
+        private static void UpdateBlockUsageBitmap(byte[] bitmap, int sectorOffsetInBitmap, bool isUsed)
+        {
+            int byteOffset = sectorOffsetInBitmap / 8;
+            int bitOffset = 7 - sectorOffsetInBitmap % 8;
+            if (isUsed)
+            {
+                bitmap[byteOffset] |= (byte)(0x01 << bitOffset);
+            }
+            else
+            {
+                bitmap[byteOffset] &= (byte)(~(0x01 << bitOffset));
+            }
+        }
+
+        /// <param name="diskSize">In bytes</param>
+        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.UnauthorizedAccessException"></exception>
+        public static VirtualHardDisk CreateDynamicDisk(string path, long diskSize)
+        {
+            const int BlockSizeInBytes = 4096 * BytesPerDiskSector;
+
+            if (diskSize % BlockSizeInBytes > 0)
+            {
+                // All blocks within a given image must be the same size
+                throw new ArgumentException("Dynamic VHD disk size must be a multiple of 2MiB");
+            }
+
+            VHDFooter footer = new VHDFooter();
+            footer.OriginalSize = (ulong)diskSize;
+            footer.CurrentSize = (ulong)diskSize;
+            footer.SetCurrentTimeStamp();
+            footer.SetDiskGeometry((ulong)diskSize / BytesPerDiskSector);
+            footer.DiskType = VirtualHardDiskType.Dynamic;
+
+            DynamicDiskHeader header = new DynamicDiskHeader();
+            header.TableOffset = VHDFooter.Length + DynamicDiskHeader.Length;
+            header.BlockSize = BlockSizeInBytes;
+            header.MaxTableEntries = (uint)Math.Ceiling((double)diskSize / BlockSizeInBytes);
+
+            BlockAllocationTable blockAllocationTable = new BlockAllocationTable(header.MaxTableEntries);
+            byte[] footerBytes = footer.GetBytes();
+            byte[] headerBytes = header.GetBytes();
+            byte[] blockAllocationTableBytes = blockAllocationTable.GetBytes();
+
+            int fileSize = VHDFooter.Length + DynamicDiskHeader.Length + blockAllocationTableBytes.Length + VHDFooter.Length;
+            RawDiskImage diskImage = RawDiskImage.Create(path, fileSize, BytesPerDiskSector);
+            diskImage.WriteSectors(0, footerBytes);
+            diskImage.WriteSectors(1, headerBytes);
+            diskImage.WriteSectors(3, blockAllocationTableBytes);
+            diskImage.WriteSectors(fileSize / BytesPerDiskSector - 1, footerBytes);
+
+            return new VirtualHardDisk(path);
+        }
+    }
+}

DiskAccessLibrary/Disks/VHD/VirtualHardDisk.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014-2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -7,7 +7,6 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
-using System.Text;
 using Utilities;
 using DiskAccessLibrary.VHD;
 
@@ -37,7 +36,7 @@ namespace DiskAccessLibrary
         {
             // We can't read the VHD footer using this.ReadSector() because it's out of the disk boundaries
             m_file = new RawDiskImage(virtualHardDiskPath, BytesPerDiskSector);
-            byte[] buffer = m_file.ReadSector(m_file.Size / m_file.BytesPerSector - 1);
+            byte[] buffer = m_file.ReadSector(m_file.Size / BytesPerDiskSector - 1);
             m_vhdFooter = new VHDFooter(buffer);
 
             if (!m_vhdFooter.IsValid)
@@ -59,8 +58,6 @@ namespace DiskAccessLibrary
                 buffer = m_file.ReadSectors(1, 2);
                 m_dynamicHeader = new DynamicDiskHeader(buffer);
                 m_blockAllocationTable = BlockAllocationTable.ReadBlockAllocationTable(virtualHardDiskPath, m_dynamicHeader);
-
-                this.IsReadOnly = true;
             }
             else
             {
@@ -101,53 +98,36 @@ namespace DiskAccessLibrary
             {
                 return m_file.ReadSectors(sectorIndex, sectorCount);
             }
-            else // dynamic
+            else // Dynamic VHD
             {
-                byte[] buffer = new byte[sectorCount * this.BytesPerSector];
-                int sectorOffset = 0;
-                while (sectorOffset < sectorCount)
-                {
-                    uint blockIndex = (uint)((sectorIndex + sectorOffset) * this.BytesPerSector / m_dynamicHeader.BlockSize);
-                    int sectorOffsetInBlock = (int)(((sectorIndex + sectorOffset) * this.BytesPerSector % m_dynamicHeader.BlockSize) / this.BytesPerSector);
-                    int sectorsInBlock = (int)(m_dynamicHeader.BlockSize / this.BytesPerSector);
-                    int sectorsRemainingInBlock = sectorsInBlock - sectorOffsetInBlock;
-                    int sectorsToRead = Math.Min(sectorCount - sectorOffset, sectorsRemainingInBlock);
-
-                    if (m_blockAllocationTable.IsBlockInUse(blockIndex))
-                    {
-                        uint blockStartSector = m_blockAllocationTable.Entries[blockIndex];
-                        // each data block has a sector bitmap preceding the data, the bitmap is padded to a 512-byte sector boundary.
-                        int blockBitmapSectorCount = (int)Math.Ceiling((double)sectorsInBlock / (this.BytesPerSector * 8));
-                        // "All sectors within a block whose corresponding bits in the bitmap are zero must contain 512 bytes of zero on disk"
-                        byte[] temp = m_file.ReadSectors(blockStartSector + blockBitmapSectorCount + sectorOffsetInBlock, sectorsToRead);
-                        ByteWriter.WriteBytes(buffer, sectorOffset * this.BytesPerSector, temp);
-                    }
-                    sectorOffset += sectorsToRead;
-                }
-                return buffer;
+                return ReadSectorsFromDynamicDisk(sectorIndex, sectorCount);
             }
         }
 
         public override void WriteSectors(long sectorIndex, byte[] data)
         {
-            CheckBoundaries(sectorIndex, data.Length / this.BytesPerSector);
-            m_file.WriteSectors(sectorIndex, data);
+            CheckBoundaries(sectorIndex, data.Length / BytesPerDiskSector);
+            if (m_vhdFooter.DiskType == VirtualHardDiskType.Fixed)
+            {
+                m_file.WriteSectors(sectorIndex, data);
+            }
+            else // Dynamic VHD
+            {
+                WriteSectorsToDynamicDisk(sectorIndex, data);
+            }
         }
 
         public override void Extend(long numberOfAdditionalBytes)
         {
-            if (numberOfAdditionalBytes % this.BytesPerSector > 0)
+            if (numberOfAdditionalBytes % BytesPerDiskSector > 0)
             {
-                throw new ArgumentException("numberOfAdditionalBytes must be a multiple of BytesPerSector");
+                throw new ArgumentException("numberOfAdditionalBytes must be a multiple of sector size");
             }
 
             if (m_vhdFooter.DiskType == VirtualHardDiskType.Fixed)
             {
-                long length = this.Size; // does not include the footer
-                m_file.Extend(numberOfAdditionalBytes);
                 m_vhdFooter.CurrentSize += (ulong)numberOfAdditionalBytes;
-                byte[] footerBytes = m_vhdFooter.GetBytes();
-                m_file.WriteSectors((length + numberOfAdditionalBytes) / this.BytesPerSector, footerBytes);
+                ExtendFile(numberOfAdditionalBytes);
             }
             else
             {
@@ -155,6 +135,18 @@ namespace DiskAccessLibrary
             }
         }
 
+        private void ExtendFile(long numberOfAdditionalBytes)
+        {
+            long footerOffset = m_file.Size - VHDFooter.Length;
+            m_file.Extend(numberOfAdditionalBytes);
+            byte[] footerBytes = m_vhdFooter.GetBytes();
+            if (m_vhdFooter.DiskType != VirtualHardDiskType.Fixed)
+            {
+                m_file.WriteSectors(0, footerBytes);
+            }
+            m_file.WriteSectors((footerOffset + numberOfAdditionalBytes) / BytesPerDiskSector, footerBytes);
+        }
+
         public long Cylinders
         {
             get
@@ -251,19 +243,19 @@ namespace DiskAccessLibrary
             cylinders = (ushort)(cylindersTimesHeads / heads);
         }
 
-        /// <param name="size">In bytes</param>
+        /// <param name="diskSize">In bytes</param>
         /// <exception cref="System.IO.IOException"></exception>
         /// <exception cref="System.UnauthorizedAccessException"></exception>
-        public static VirtualHardDisk Create(string path, long size)
+        public static VirtualHardDisk Create(string path, long diskSize)
         {
             VHDFooter footer = new VHDFooter();
-            footer.OriginalSize = (ulong)size;
-            footer.CurrentSize = (ulong)size;
+            footer.OriginalSize = (ulong)diskSize;
+            footer.CurrentSize = (ulong)diskSize;
             footer.SetCurrentTimeStamp();
-            footer.SetDiskGeometry((ulong)size / BytesPerDiskSector);
+            footer.SetDiskGeometry((ulong)diskSize / BytesPerDiskSector);
 
-            RawDiskImage diskImage = RawDiskImage.Create(path, size + VHDFooter.Length, BytesPerDiskSector);
-            diskImage.WriteSectors(size / BytesPerDiskSector, footer.GetBytes());
+            RawDiskImage diskImage = RawDiskImage.Create(path, diskSize + VHDFooter.Length, BytesPerDiskSector);
+            diskImage.WriteSectors(diskSize / BytesPerDiskSector, footer.GetBytes());
 
             return new VirtualHardDisk(path);
         }

DiskAccessLibrary/FileSystems/NTFS/AttributeRecord/NonResidentAttributeRecord.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -7,7 +7,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 using Utilities;
 
 namespace DiskAccessLibrary.FileSystems.NTFS
@@ -276,6 +275,16 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         }
 
         /// <summary>
+        /// This method should only be used for informational purposes.
+        /// </summary>
+        public KeyValuePairList<long, int> GetClustersInUse()
+        {
+            long clusterCount = HighestVCN - LowestVCN + 1;
+            KeyValuePairList<long, int> sequence = m_dataRunSequence.TranslateToLCN(0, (int)clusterCount);
+            return sequence;
+        }
+
+        /// <summary>
         /// When reading attributes, they may contain additional padding,
         /// so we should use StoredRecordLength to advance the buffer position instead.
         /// </summary>
@@ -304,7 +313,7 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         {
             get
             {
-                return m_dataRunSequence.DataClusterCount;
+                return HighestVCN - LowestVCN + 1;;
             }
         }
     }

DiskAccessLibrary/FileSystems/NTFS/ClusterUsageBitmap.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -7,7 +7,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 using Utilities;
 
 namespace DiskAccessLibrary.FileSystems.NTFS
@@ -207,8 +206,8 @@ namespace DiskAccessLibrary.FileSystems.NTFS
 
         public static void UpdateClusterStatus(byte[] bitmap, ulong clusterIndexInBitmap, bool isUsed)
         {
-            ulong byteOffset = (ulong)clusterIndexInBitmap / 8;
-            int bitOffset = (int)clusterIndexInBitmap % 8;
+            ulong byteOffset = clusterIndexInBitmap / 8;
+            int bitOffset = (int)(clusterIndexInBitmap % 8);
             if (isUsed)
             {
                 bitmap[byteOffset] |= (byte)(0x01 << bitOffset);

DiskAccessLibrary/FileSystems/NTFS/FileRecord/FileRecordSegment.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -7,7 +7,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 using Utilities;
 
 namespace DiskAccessLibrary.FileSystems.NTFS
@@ -61,7 +60,10 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         public FileRecordSegment(byte[] buffer, int offset, int bytesPerSector, long segmentNumber)
         {
             Signature = ByteReader.ReadAnsiString(buffer, offset + 0x00, 4);
-
+            if (Signature != ValidSignature)
+            {
+                throw new InvalidDataException("Invalid FILE record signature");
+            }
             ushort updateSequenceArrayOffset = LittleEndianConverter.ToUInt16(buffer, offset + 0x04);
             ushort updateSequenceArraySize = LittleEndianConverter.ToUInt16(buffer, offset + 0x06);
             LogFileSequenceNumber = LittleEndianConverter.ToUInt64(buffer, offset + 0x08);

DiskAccessLibrary/FileSystems/NTFS/Index/IndexRecord.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2018 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -6,7 +6,7 @@
  */
 using System;
 using System.Collections.Generic;
-using System.Text;
+using System.IO;
 using Utilities;
 
 namespace DiskAccessLibrary.FileSystems.NTFS
@@ -40,6 +40,10 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         public IndexRecord(byte[] buffer, int offset)
         {
             Signature = ByteReader.ReadAnsiString(buffer, offset + 0x00, 4);
+            if (Signature != ValidSignature)
+            {
+                throw new InvalidDataException("Invalid INDX record signature");
+            }
             ushort updateSequenceArrayOffset = LittleEndianConverter.ToUInt16(buffer, offset + 0x04);
             ushort updateSequenceArraySize = LittleEndianConverter.ToUInt16(buffer, offset + 0x06);
             LogFileSequenceNumber = LittleEndianConverter.ToUInt64(buffer, offset + 0x08);

DiskAccessLibrary/Properties/AssemblyInfo.cs

@@ -31,5 +31,5 @@ using System.Runtime.InteropServices;
 //
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("1.4.7.0")]
-[assembly: AssemblyFileVersion("1.4.7.0")]
+[assembly: AssemblyVersion("1.4.8.0")]
+[assembly: AssemblyFileVersion("1.4.8.0")]

DiskAccessLibrary/RevisionHistory.txt

@@ -1,8 +1,8 @@
 Revision History:
 -----------------
 1.1.0 - LDM related bugfix.
-		NTFS related bugfix and code clean up.
-		
+        NTFS related bugfix and code clean up.
+
 1.1.1 - Minor enhancements.
 
 1.1.2 - Better handling of a corrupted LDM database.
@@ -10,37 +10,37 @@ Revision History:
 1.1.3 - Disabled file system caching for virtual disks.
 
 1.1.4 - Fixed GPT partition size detection bug.
-		Allow reading from disks that are opened for write access by other applications.
+        Allow reading from disks that are opened for write access by other applications.
 
 1.1.5 - Improved disk detection mechanism.
-		Added limited VMDK support (monolithic flat).
+        Added limited VMDK support (monolithic flat).
 
 1.1.6 - Use the SetFileValidData() Windows API call to extend virtual disks faster.
 
 1.1.7 - Fixed VMDK related bug (flat files that have a space in their filename).
-		Added support for reading a monolithic sparse VMDK.
+        Added support for reading a monolithic sparse VMDK.
 
 1.1.8 - Fixed NTFS related issues.
 
 1.1.9 - Disks are now orderered according to disk number.
-		Code clean up.
+        Code clean up.
 
 1.2.0 - NTFS related bugfixes.
-		Write operations on readonly disks are no longer silently ignored and now raising exceptions, added missing readonly check to VMDK files.
+        Write operations on readonly disks are no longer silently ignored and now raising exceptions, added missing readonly check to VMDK files.
 
 1.2.1 - Minor enhancements and fixes.
 
 1.2.2 - Minor NTFS changes.
 
 1.2.3 - Fixed: LDM extent record now properly support the 0x40 flag.
-		Added helper methods for taking a disk online/offline.
+        Added helper methods for taking a disk online/offline.
 
 1.2.4 - NTFS related fixes.
 
 1.2.5 - Added support for reading dynamic VHDs.
 
 1.2.6 - More meaningful exceptions types are now thrown on errors.
-		Dynamic VHD related bugfix.
+        Dynamic VHD related bugfix.
 
 1.2.7 - Minor improvements.
 
@@ -50,7 +50,7 @@ Revision History:
       - Bugfix: VHD was not extended to the correct size.
 
 1.2.9 - We now use the same caching policy for virtual disk read and write operations. (Workaround for hosts without KB981166).
-	  - Bugfix: GPT header checksum verification failed if the size of the partition entries was not a multiple of sector size.
+      - Bugfix: GPT header checksum verification failed if the size of the partition entries was not a multiple of sector size.
 
 1.3.0 - Fixed a bug related to the RESUME boot sector.
 
@@ -102,8 +102,17 @@ Revision History:
 
 1.4.6 - Win32Errors enum: Added ERROR_INVALID_DATA
         Bugfix: The second KLOG page was not read.
-		Minor changes and improvements.
+        Minor changes and improvements.
         Corrected documentation.
 
 1.4.7 - Bugfix: NTFS File Records that exceeded 511 bytes were corrupted during write.
         Minor improvements to NTFS Data Run record implementation.
+
+1.4.8 - NTFS: ClusterUsageBitmap: Cosmetic improvements.
+        NTFS: Throw InvalidDataException if FILE or INDX record signature is invalid.
+        NTFS: NonResidentAttributeRecord: Minor optimization.
+        NTFS: NonResidentAttributeRecord: Added GetClustersInUse() method.        
+        VHD: BlockAllocationTable: Improved implementation.
+        VHD: DynamicDiskHeader: Improved implementation.
+        VHD: Implemented dynamic VHD write functionality.
+        Minor changes and improvements.