Blog

A couple times a year, Vertigo supports a computer recycling drive. I happen to have a lot of old hard drives that I really wanted to give away, but not without wiping first. Not knowing how to do direct disk access in Win32, I was about to install an old compiler and implement something for DOS, invoking subfunction 7305h. Fortunately, in passing, I came across the Win32 function, CreateFile. Despite its name, CreateFile actually produces handles for accessing files [which don't have to be new]. Further, it can also target partitions and physical drives, passing in as the filename:

• \.\PhysicalDriven - access hard disk n
• \\.\s: - access partition s

These cases require full R/W access—the documentation states GENERIC_READ | GENERIC_WRITE is sufficient—and read and write sharing. So opening the x: partition for synchronous access would be:

String fileName =  L"\\.\x:";
pin_ptr pName = &(fileName->ToCharArray()[0]);
HANDLE hFile =
    CreateFile(
        L"\\.\x:",
        FILE_ALL_ACCESS,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        0,
        NULL);
pName = nullptr;

if (hFile == INVALID_HANDLE_VALUE)
{
    if (GetLastError() == 0)
    {
        Throw Exception: Drive/partition does not exist.
    }
    else
    {
        Throw Exception: Can't open drive/partition.                
    }
}

The file handle can then then be wrapped in a SafeFileHandle so it can be closed with disposal:

SafeFileHandle^ safeFileHandle = nullptr;
try
{
    safeFileHandle = 
        gcnew SafeFileHandle((IntPtr)hFile, true);  // Current thread owns handle.

    ...

}
finally
{
    if (safeFileHandle != nullptr)
    {
        delete safeFileHandle;
    }
}

In turn, this can be passed into a FileStream constructor, through which the actual I/O can be performed:

// FileAccess::Read can be used for read access.
fileStream = gcnew FileStream(safeFileHandle, FileAccess::Write);

The FileStream is now available for writing [or reading]:

fileStream->Write(
    byteArray,
    0,
    byteArray->Length);

In addition, the FileStream's position can be changed:

fileStream->Position = position;

Notes:

• While opening partitions and physical drives doesn't require Administrator access, many of the related I/O functions do—and for good reason!
• To get a physical disk's size, use the DeviceIOControl function, passing in IOCTL_DISK_GET_LENGTH_INFO:

  DWORD bytesReturned;
  GET_LENGTH_INFORMATION getLengthInformation;
  
  if (FALSE == DeviceIOControl(
          hFile,
          IOCTL_DISK_GET_LENGTH_INFO.
          NULL,
          0,
          &getLengthInformation,
          sizeof(GET_LENGTH_INFORMATION),
          &bytesReturned,
          NULL))
  {
      Throw Exception: Can't get disk length
  }
  
  Int64 diskLength = getLengthInformation.Length.QuadPart;

• The DriveInfo class doesn't reveal a partition's full size—perhaps it takes file system overhead into account. To get a partition's length, use the DeviceIOControl function, passing in IOCTL_DISK_GET_PARTITION_INFO_EX:

  DWORD bytesReturned;
  PARTITION_INFORMATION_EX partitionInfo;
  
  if (FALSE == DeviceIOControl(
          hFile,
          IOCTL_DISK_GET_PARTITION_INFO_EX,
          NULL,
          0,
          &partitionInfo,
          sizeof(PARTITION_INFORMATION_EX),
          &bytesReturned,
          NULL))
  {
      Throw Exception: Can't get partition info.
  }
  
  Int64 partitionLength = partitionInfo.PartitionLength.QuadPart;

• Partitions should be dismounted before writing, using the DeviceIOControl function with FSCTL_DISMOUNT_VOLUME:

  DWORD bytesReturned;
  
  if (FALSE == DeviceIoControl(
          hFile,
          FSCTL_DISMOUNT_VOLUME ,
          NULL,
          0,
          NULL,
          0,
          &bytesReturned,
          NULL))
  {
      Throw Exception: Partition can't be dismounted.
  }

• It seems that you can't have partially-written sectors when you flush.
• I tested the direct physical disk and partition I/O on 32-bit Vista and XP, and was able to access IDE drives. However, I couldn't get the API's to work with my USB floppy drive.
• I never tested these API's with dynamic or encrypted partitions.
• While the interop will require more work, these API's can be accessed in C#. pinvoke.net has entries for CreateFile and DeviceIOControl.
• In most cases, a few random passes is probably good enough for wiping disks and partitions—be sure to use RNGCryptoServiceProvider or one of the CNG RNG algorithms as a source. For more security, patterns included in this article, targetting specific disk encodings, can be written instead.
• Needless to say, direct disk and partition I/O is inherently dangerous—though using the Win32 and .NET framework API's isn't as error-prone as the DOS interrupt ones. However, use them at your own risk. Also, be sure to implement a good, descriptive user confirmation before starting to write.