public void ManyAttributes()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
using (Stream s = ntfs.OpenFile(@"file", FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(32);
}
for (int i = 0; i < 50; ++i)
{
ntfs.CreateHardLink("file", "hl" + i);
}
using (Stream s = ntfs.OpenFile("hl35", FileMode.Open, FileAccess.ReadWrite))
{
Assert.Equal(32, s.ReadByte());
s.Position = 0;
s.WriteByte(12);
}
using (Stream s = ntfs.OpenFile("hl5", FileMode.Open, FileAccess.ReadWrite))
{
Assert.Equal(12, s.ReadByte());
}
for (int i = 0; i < 50; ++i)
{
ntfs.DeleteFile("hl" + i);
}
Assert.Equal(1, ntfs.GetFiles(@"\").Length);
ntfs.DeleteFile("file");
Assert.Equal(0, ntfs.GetFiles(@"\").Length);
}
public static void GetDirListing(string VMDKpath, string directory)
{
if (File.Exists(VMDKpath))
{
try
{
using (VirtualDisk vhdx = VirtualDisk.OpenDisk(VMDKpath, FileAccess.Read))
{
if (vhdx.Partitions.Count > 1)
{
Console.WriteLine("Target has more than one partition");
for (var i = 0; i <= vhdx.Partitions.Count; i++)
{
NtfsFileSystem vhdbNtfs = new NtfsFileSystem(vhdx.Partitions[i].Open());
if (vhdbNtfs.DirectoryExists("\\\\" + directory))
{
string[] filelist = vhdbNtfs.GetFiles(vhdbNtfs.Root.FullName + directory);
string[] dirlist = vhdbNtfs.GetDirectories(vhdbNtfs.Root.FullName + directory);
foreach (var file in filelist)
{
Console.WriteLine("[F] {0}", file);
}
foreach (var dir in dirlist)
{
Console.WriteLine("[D] {0}", dir);
}
}
else
{
Console.WriteLine("\r\n[*] Directory does not exist");
}
}
}
else
{
NtfsFileSystem vhdbNtfs = new NtfsFileSystem(vhdx.Partitions[0].Open());
if (vhdbNtfs.DirectoryExists("\\\\" + directory))
{
string[] filelist = vhdbNtfs.GetFiles(vhdbNtfs.Root.FullName + directory);
string[] dirlist = vhdbNtfs.GetDirectories(vhdbNtfs.Root.FullName + directory);
foreach (var file in filelist)
{
Console.WriteLine("[F] {0} {1}", file, vhdbNtfs.GetFileLength(file));
}
foreach (var dir in dirlist)
{
Console.WriteLine("[D] {0}", dir);
}
}
else
{
Console.WriteLine("\r\n[*] Directory does not exist");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("\r\n [!] Virtual Disk provided is not supported");
Console.WriteLine("\r\n [!] An exception occured: {0}", ex);
Environment.Exit(1);
}
}
else
{
Console.WriteLine("\r\n [!] The provided VMDK image does not exist or can not be accessed");
}
}
public string[] GetFileSystemEntries()
{
return(_ntfs.GetFiles("", "*.*", SearchOption.AllDirectories));
}
protected override void DoRun()
{
if (!IsAdministrator())
{
Console.WriteLine("\nThis utility must be run as an administrator!\n");
Environment.Exit(1);
}
DiskImageBuilder builder = DiskImageBuilder.GetBuilder(OutputDiskType, OutputDiskVariant);
builder.GenericAdapterType = AdapterType;
string[] sourceVolume = _volumes.Values;
uint diskNumber;
List <CloneVolume> cloneVolumes = GatherVolumes(sourceVolume, out diskNumber);
if (!Quiet)
{
Console.WriteLine("Inspecting Disk...");
}
// Construct a stream representing the contents of the cloned disk.
BiosPartitionedDiskBuilder contentBuilder;
Geometry biosGeometry;
Geometry ideGeometry;
long capacity;
using (Disk disk = new Disk(diskNumber))
{
contentBuilder = new BiosPartitionedDiskBuilder(disk);
biosGeometry = disk.BiosGeometry;
ideGeometry = disk.Geometry;
capacity = disk.Capacity;
}
// Preserve the IDE (aka Physical) geometry
builder.Geometry = ideGeometry;
// Translate the BIOS (aka Logical) geometry
GeometryTranslation translation = _translation.EnumValue;
if (builder.PreservesBiosGeometry && translation == GeometryTranslation.Auto)
{
// If the new format preserves BIOS geometry, then take no action if asked for 'auto'
builder.BiosGeometry = biosGeometry;
translation = GeometryTranslation.None;
}
else
{
builder.BiosGeometry = ideGeometry.TranslateToBios(0, translation);
}
if (translation != GeometryTranslation.None)
{
contentBuilder.UpdateBiosGeometry(builder.BiosGeometry);
}
IVssBackupComponents backupCmpnts;
int status;
if (Marshal.SizeOf(typeof(IntPtr)) == 4)
{
status = NativeMethods.CreateVssBackupComponents(out backupCmpnts);
}
else
{
status = NativeMethods.CreateVssBackupComponents64(out backupCmpnts);
}
Guid snapshotSetId = CreateSnapshotSet(cloneVolumes, backupCmpnts);
if (!Quiet)
{
Console.Write("Copying Disk...");
}
foreach (var sv in cloneVolumes)
{
Volume sourceVol = new Volume(sv.SnapshotProperties.SnapshotDeviceObject, sv.SourceExtent.ExtentLength);
SnapshotStream rawVolStream = new SnapshotStream(sourceVol.Content, Ownership.None);
rawVolStream.Snapshot();
byte[] volBitmap;
int clusterSize;
using (NtfsFileSystem ntfs = new NtfsFileSystem(rawVolStream))
{
ntfs.NtfsOptions.HideSystemFiles = false;
ntfs.NtfsOptions.HideHiddenFiles = false;
ntfs.NtfsOptions.HideMetafiles = false;
// Remove VSS snapshot files (can be very large)
foreach (string filePath in ntfs.GetFiles(@"\System Volume Information", "*{3808876B-C176-4e48-B7AE-04046E6CC752}"))
{
ntfs.DeleteFile(filePath);
}
// Remove the page file
if (ntfs.FileExists(@"\Pagefile.sys"))
{
ntfs.DeleteFile(@"\Pagefile.sys");
}
// Remove the hibernation file
if (ntfs.FileExists(@"\hiberfil.sys"))
{
ntfs.DeleteFile(@"\hiberfil.sys");
}
using (Stream bitmapStream = ntfs.OpenFile(@"$Bitmap", FileMode.Open))
{
volBitmap = new byte[bitmapStream.Length];
int totalRead = 0;
int numRead = bitmapStream.Read(volBitmap, 0, volBitmap.Length - totalRead);
while (numRead > 0)
{
totalRead += numRead;
numRead = bitmapStream.Read(volBitmap, totalRead, volBitmap.Length - totalRead);
}
}
clusterSize = (int)ntfs.ClusterSize;
if (translation != GeometryTranslation.None)
{
ntfs.UpdateBiosGeometry(builder.BiosGeometry);
}
}
List <StreamExtent> extents = new List <StreamExtent>(BitmapToRanges(volBitmap, clusterSize));
SparseStream partSourceStream = SparseStream.FromStream(rawVolStream, Ownership.None, extents);
for (int i = 0; i < contentBuilder.PartitionTable.Partitions.Count; ++i)
{
var part = contentBuilder.PartitionTable.Partitions[i];
if (part.FirstSector * 512 == sv.SourceExtent.StartingOffset)
{
contentBuilder.SetPartitionContent(i, partSourceStream);
}
}
}
SparseStream contentStream = contentBuilder.Build();
// Write out the disk images
string dir = Path.GetDirectoryName(_destDisk.Value);
string file = Path.GetFileNameWithoutExtension(_destDisk.Value);
builder.Content = contentStream;
DiskImageFileSpecification[] fileSpecs = builder.Build(file);
for (int i = 0; i < fileSpecs.Length; ++i)
{
// Construct the destination file path from the directory of the primary file.
string outputPath = Path.Combine(dir, fileSpecs[i].Name);
// Force the primary file to the be one from the command-line.
if (i == 0)
{
outputPath = _destDisk.Value;
}
using (SparseStream vhdStream = fileSpecs[i].OpenStream())
using (FileStream fs = new FileStream(outputPath, FileMode.Create, FileAccess.ReadWrite))
{
StreamPump pump = new StreamPump()
{
InputStream = vhdStream,
OutputStream = fs,
};
long totalBytes = 0;
foreach (var se in vhdStream.Extents)
{
totalBytes += se.Length;
}
if (!Quiet)
{
Console.WriteLine();
DateTime now = DateTime.Now;
pump.ProgressEvent += (o, e) => { ShowProgress(fileSpecs[i].Name, totalBytes, now, o, e); };
}
pump.Run();
if (!Quiet)
{
Console.WriteLine();
}
}
}
// Complete - tidy up
CallAsyncMethod(backupCmpnts.BackupComplete);
long numDeleteFailed;
Guid deleteFailed;
backupCmpnts.DeleteSnapshots(snapshotSetId, 2 /*VSS_OBJECT_SNAPSHOT_SET*/, true, out numDeleteFailed, out deleteFailed);
Marshal.ReleaseComObject(backupCmpnts);
}
private void CopyFiles(NtfsFileSystem sourceNtfs, NtfsFileSystem destNtfs, string path, bool subs)
{
if (subs)
{
foreach (var dir in sourceNtfs.GetDirectories(path))
{
if (!IsExcluded(dir))
{
int hardLinksRemaining = sourceNtfs.GetHardLinkCount(dir) - 1;
bool newDir = false;
long sourceFileId = sourceNtfs.GetFileId(dir);
string refPath;
if (_uniqueFiles.TryGetValue(sourceFileId, out refPath))
{
// If this is another name for a known dir, recreate the hard link
destNtfs.CreateHardLink(refPath, dir);
}
else
{
destNtfs.CreateDirectory(dir);
newDir = true;
FileAttributes fileAttrs = sourceNtfs.GetAttributes(dir);
if ((fileAttrs & FileAttributes.ReparsePoint) != 0)
{
destNtfs.SetReparsePoint(dir, sourceNtfs.GetReparsePoint(dir));
}
destNtfs.SetAttributes(dir, fileAttrs);
destNtfs.SetSecurity(dir, sourceNtfs.GetSecurity(dir));
}
// File may have a short name
string shortName = sourceNtfs.GetShortName(dir);
if (!string.IsNullOrEmpty(shortName) && shortName != dir)
{
destNtfs.SetShortName(dir, shortName);
--hardLinksRemaining;
}
if (newDir)
{
if (hardLinksRemaining > 0)
{
_uniqueFiles[sourceFileId] = dir;
}
CopyFiles(sourceNtfs, destNtfs, dir, subs);
}
// Set standard information last (includes modification timestamps)
destNtfs.SetFileStandardInformation(dir, sourceNtfs.GetFileStandardInformation(dir));
}
}
}
foreach (var file in sourceNtfs.GetFiles(path))
{
Console.WriteLine(file);
int hardLinksRemaining = sourceNtfs.GetHardLinkCount(file) - 1;
long sourceFileId = sourceNtfs.GetFileId(file);
string refPath;
if (_uniqueFiles.TryGetValue(sourceFileId, out refPath))
{
// If this is another name for a known file, recreate the hard link
destNtfs.CreateHardLink(refPath, file);
}
else
{
CopyFile(sourceNtfs, destNtfs, file);
if (hardLinksRemaining > 0)
{
_uniqueFiles[sourceFileId] = file;
}
}
// File may have a short name
string shortName = sourceNtfs.GetShortName(file);
if (!string.IsNullOrEmpty(shortName) && shortName != file)
{
destNtfs.SetShortName(file, shortName);
}
}
}
public static void GetDirListing(string DiskPath, string directory)
{
if (File.Exists(DiskPath))
{
try
{
VolumeManager volMgr = new VolumeManager();
VirtualDisk vhdx = VirtualDisk.OpenDisk(DiskPath, FileAccess.Read);
volMgr.AddDisk(vhdx);
VolumeInfo volInfo = null;
if (vhdx.Partitions.Count > 1)
{
Console.WriteLine("\r\n[*] Target has more than one partition\r\n");
foreach (var physVol in volMgr.GetPhysicalVolumes())
{
Console.WriteLine(" Identity: " + physVol.Identity);
Console.WriteLine(" Type: " + physVol.VolumeType);
Console.WriteLine(" Disk Id: " + physVol.DiskIdentity);
Console.WriteLine(" Disk Sig: " + physVol.DiskSignature.ToString("X8"));
Console.WriteLine(" Part Id: " + physVol.PartitionIdentity);
Console.WriteLine(" Length: " + physVol.Length + " bytes");
Console.WriteLine(" Disk Geometry: " + physVol.PhysicalGeometry);
Console.WriteLine(" First Sector: " + physVol.PhysicalStartSector);
Console.WriteLine();
if (!string.IsNullOrEmpty(physVol.Identity))
{
volInfo = volMgr.GetVolume(physVol.Identity);
}
using (NtfsFileSystem vhdbNtfs = new NtfsFileSystem(physVol.Partition.Open()))
{
if (vhdbNtfs.DirectoryExists("\\\\" + directory))
{
string[] filelist = vhdbNtfs.GetFiles(vhdbNtfs.Root.FullName + directory);
string[] dirlist = vhdbNtfs.GetDirectories(vhdbNtfs.Root.FullName + directory);
foreach (var file in filelist)
{
Console.WriteLine("[F] {0} {1}", file, vhdbNtfs.GetFileLength(file));
}
foreach (var dir in dirlist)
{
Console.WriteLine("[D] {0}", dir);
}
}
else
{
Console.WriteLine("\r\n[*] Directory does not exist in partition {0}\r\n",
physVol.Identity);
}
}
}
}
else //No partitions
{
Console.WriteLine("\r\n[*] Found only one partition\r\n");
Console.WriteLine("LOGICAL VOLUMES");
foreach (var logVol in volMgr.GetLogicalVolumes())
{
Console.WriteLine(" Identity: " + logVol.Identity);
Console.WriteLine(" Length: " + logVol.Length + " bytes");
Console.WriteLine(" Disk Geometry: " + logVol.PhysicalGeometry);
Console.WriteLine(" First Sector: " + logVol.PhysicalStartSector);
Console.WriteLine();
}
using (NtfsFileSystem vhdbNtfs = new NtfsFileSystem(vhdx.Partitions[0].Open()))
{
if (vhdbNtfs.DirectoryExists("\\\\" + directory))
{
string[] filelist = vhdbNtfs.GetFiles(vhdbNtfs.Root.FullName + directory);
string[] dirlist = vhdbNtfs.GetDirectories(vhdbNtfs.Root.FullName + directory);
foreach (var file in filelist)
{
Console.WriteLine("[F] {0} {1}", file, vhdbNtfs.GetFileLength(file));
}
foreach (var dir in dirlist)
{
Console.WriteLine("[D] {0}", dir);
}
}
else
{
Console.WriteLine("\r\n[*] Directory does not exist");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Exception {0}", ex);
}
}
}