//StorageCheckVerify
//StorageCheckVerify2
//StorageMediaRemoval
public STORAGE_DEVICE_DESCRIPTOR_PARSED StorageGetDeviceProperty()
{
STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY();
query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
query.PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty;
byte[] res = DeviceIoControlHelper.InvokeIoControlUnknownSize(Handle, IOControlCode.StorageQueryProperty, query);
STORAGE_DEVICE_DESCRIPTOR descriptor = Utils.ByteArrayToStruct <STORAGE_DEVICE_DESCRIPTOR>(res, 0);
STORAGE_DEVICE_DESCRIPTOR_PARSED returnValue = new STORAGE_DEVICE_DESCRIPTOR_PARSED();
returnValue.Version = descriptor.Version;
returnValue.Size = descriptor.Size;
returnValue.DeviceType = descriptor.DeviceType;
returnValue.DeviceTypeModifier = descriptor.DeviceTypeModifier;
returnValue.RemovableMedia = descriptor.RemovableMedia;
returnValue.CommandQueueing = descriptor.CommandQueueing;
returnValue.VendorIdOffset = descriptor.VendorIdOffset;
returnValue.ProductIdOffset = descriptor.ProductIdOffset;
returnValue.ProductRevisionOffset = descriptor.ProductRevisionOffset;
returnValue.SerialNumberOffset = descriptor.SerialNumberOffset;
returnValue.BusType = descriptor.BusType;
returnValue.RawPropertiesLength = descriptor.RawPropertiesLength;
returnValue.RawDeviceProperties = descriptor.RawDeviceProperties;
returnValue.SerialNumber = Utils.ReadNullTerminatedAsciiString(res, (int)descriptor.SerialNumberOffset);
return(returnValue);
}
/// <summary>
/// CheckTrim Checks for trim descriptor
/// </summary>
/// <param name="DiskIndex">Physical disk index</param>
/// <returns>
/// true if trim is enabled else false.
/// </returns>
private static bool CheckTrim(int DiskIndex)
{
DEVICE_TRIM_DESCRIPTOR TrimDesc = new DEVICE_TRIM_DESCRIPTOR();
STORAGE_PROPERTY_QUERY StorageQuery = new STORAGE_PROPERTY_QUERY();
uint BytesReturned = 0;
StorageQuery.PropertyId = STORAGE_PROPERTY_ID.StorageDeviceTrimProperty;
StorageQuery.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
IntPtr StorageQueryPtr = Marshal.AllocHGlobal(Marshal.SizeOf(StorageQuery));
IntPtr TrimDescPtr = Marshal.AllocHGlobal(Marshal.SizeOf(TrimDesc));
Marshal.StructureToPtr(StorageQuery, StorageQueryPtr, false);
Marshal.StructureToPtr(TrimDesc, TrimDescPtr, false);
SafeFileHandle physicalDisk = DeviceIO.CreateFile(
"\\\\.\\PhysicalDrive" + DiskIndex,
GENERIC_READ,
FILE_SHARE_READ,
IntPtr.Zero,
OPEN_EXISTING,
FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
IntPtr.Zero);
bool rs = DeviceIoControl(physicalDisk, IOCTL_STORAGE_QUERY_PROPERTY, StorageQueryPtr,
(uint)Marshal.SizeOf(StorageQuery), TrimDescPtr, (uint)Marshal.SizeOf(TrimDesc),
ref BytesReturned, IntPtr.Zero);
if (rs == false)
{
throw new Exception();
}
TrimDesc = (DEVICE_TRIM_DESCRIPTOR)Marshal.PtrToStructure(TrimDescPtr, typeof(DEVICE_TRIM_DESCRIPTOR));
return(TrimDesc.TrimEnabled);
}
/// <summary>
/// pDeviceName : Device name.
/// Returns : True if the STORAGE_DEVICE_DESCRIPTOR structure has been loaded successfully.
/// </summary>
public bool Load(string pDeviceName)
{
var succeeded = false;
var hDevice = NativeMethods.CreateFile(pDeviceName, 0, NativeConstants.FILE_SHARE_READ | NativeConstants.FILE_SHARE_WRITE, IntPtr.Zero, NativeConstants.OPEN_EXISTING, 0, IntPtr.Zero);
if (hDevice != NativeConstants.INVALID_HANDLE_VALUE)
{
Unload();
var spq = new STORAGE_PROPERTY_QUERY {
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty, QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery
};
if (NativeMethods.DeviceIoControl(hDevice, NativeConstants.IOCTL_STORAGE_QUERY_PROPERTY, ref spq, Marshal.SizeOf(spq), out var sdh, Marshal.SizeOf(typeof(STORAGE_DESCRIPTOR_HEADER)), out _, IntPtr.Zero))
{
_pDescriptor = Marshal.AllocHGlobal(sdh.Size);
succeeded = NativeMethods.DeviceIoControl(hDevice, NativeConstants.IOCTL_STORAGE_QUERY_PROPERTY, ref spq, Marshal.SizeOf(spq), _pDescriptor, sdh.Size, out _, IntPtr.Zero);
}
NativeMethods.CloseHandle(hDevice);
}
if (succeeded)
{
_descriptor = Marshal.PtrToStructure <STORAGE_DEVICE_DESCRIPTOR>(_pDescriptor);
}
else
{
Unload();
}
return(succeeded);
}
/// <summary>
/// Gets the serial number of the specified physical driver.
/// </summary>
/// <param name="DriveName">Name of the disk drive.</param>
public static unsafe string Example_QueryDiskSerial(string DriveName = "PhysicalDrive0")
{
var SerialNumber = (string)null;
//
// Open the symbolic link created by the disk driver.
//
var DiskDevice = new DeviceIoControl("\\\\.\\" + DriveName);
DiskDevice.Connect();
//
// Prepare a request to send to the disk driver.
//
var Desc = new STORAGE_DESCRIPTOR_HEADER();
var Query = new STORAGE_PROPERTY_QUERY
{
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty,
QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery
};
//
// Call the disk driver's IRP handler.
//
if (DiskDevice.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), &Desc, Marshal.SizeOf(Desc)))
{
var Allocation = Marshal.AllocHGlobal(Desc.Size);
if (DiskDevice.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), Allocation.ToPointer(), Desc.Size))
{
var DeviceDesc = Marshal.PtrToStructure <STORAGE_DEVICE_DESCRIPTOR>(Allocation);
if (DeviceDesc.SerialNumberOffset != 0)
{
SerialNumber = Marshal.PtrToStringAnsi(IntPtr.Add(Allocation, DeviceDesc.SerialNumberOffset), Desc.Size - DeviceDesc.SerialNumberOffset);
SerialNumber = SerialNumber.Trim('\0');
}
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor.");
}
Marshal.FreeHGlobal(Allocation);
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor size.");
}
DiskDevice.Close();
Console.WriteLine($"[*] Disk Serial: {SerialNumber}");
return(SerialNumber);
}
public static extern bool DeviceIoControl(
SafeFileHandle hDevice,
uint dwIoControlCode,
ref STORAGE_PROPERTY_QUERY lpInBuffer, // To get disk information.
uint nInBufferSize,
out STORAGE_DEVICE_DESCRIPTOR lpOutBuffer, // To get disk information.
uint nOutBufferSize,
out uint lpBytesReturned,
IntPtr lpOverlapped);
public static extern Boolean DeviceIoControl(
SafeFileHandle hDevice,
uint dwIoControlCode,
ref STORAGE_PROPERTY_QUERY InBuffer,
int nInBufferSize,
ref STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR OutBuffer,
int nOutBufferSize,
ref int pBytesReturned,
IntPtr lpOverlapped);
private static extern bool DeviceIoControl(
SafeFileHandle hDevice,
uint dwIoControlCode,
ref STORAGE_PROPERTY_QUERY lpInBuffer,
uint nInBufferSize,
ref DEVICE_SEEK_PENALTY_DESCRIPTOR lpOutBuffer,
uint nOutBufferSize,
out uint lpBytesReturned,
IntPtr lpOverlapped);
internal static extern bool DeviceIoControl
(
SafeHandle hDevice,
IOCTL dwIoControlCode,
ref STORAGE_PROPERTY_QUERY lpInBuffer,
int nInBufferSize,
IntPtr lpOutBuffer,
uint nOutBufferSize,
out uint lpBytesReturned,
IntPtr lpOverlapped);
NvmeSmartAttributesProvider(SafeFileHandle hDrive, string deviceId, string moniker)
{
try
{
#pragma warning disable CA1416
using var searcher = new ManagementObjectSearcher($"SELECT Model, SerialNumber FROM Win32_DiskDrive WHERE DeviceID=\"{deviceId.Replace("\\", "\\\\")}\"");
foreach (var item in searcher.Get())
{
SerialNumber = item["SerialNumber"].ToString().Replace("_", string.Empty).Replace(".", string.Empty);
Model = item["Model"].ToString();
break;
}
#pragma warning restore CA1416
}
catch
{
}
Moniker = moniker;
DeviceId = deviceId;
this.hDrive = hDrive;
cbStoragePropertyQueryLength = (uint)SizeOf <STORAGE_PROPERTY_QUERY>();
cbStorageProtocolSpecificDataLength = (uint)SizeOf <STORAGE_PROTOCOL_SPECIFIC_DATA>();
cbStorageProtocolSpecificDataOffset = (uint)OffsetOf <STORAGE_PROPERTY_QUERY>("AdditionalParameters").ToInt32();
cbStorageProtocolDataDescriptorLength = (uint)SizeOf <STORAGE_PROTOCOL_DATA_DESCRIPTOR>();
cbNvmeHealthInfoLogLength = (uint)SizeOf <NVME_HEALTH_INFO_LOG>();
cbNvmeHealthInfoLogOffset = (uint)OffsetOf <STORAGE_PROTOCOL_DATA_DESCRIPTOR>("ProtocolSpecificData").ToInt32();
cbBuffer = cbStorageProtocolSpecificDataOffset + cbStorageProtocolSpecificDataLength + Constants.NVME_MAX_LOG_SIZE;
lpStoragePropertyQuery = AllocHGlobal((int)cbStoragePropertyQueryLength);
lpStorageProtocolSpecificData = AllocHGlobal((int)cbStorageProtocolSpecificDataLength);
lpStorageProtocolDataDescriptor = AllocHGlobal((int)cbStorageProtocolDataDescriptorLength);
lpNvmeHealthInfoLog = AllocHGlobal((int)cbNvmeHealthInfoLogLength);
lpBuffer = new byte[cbBuffer];
var storagePropertyQuery = new STORAGE_PROPERTY_QUERY
{
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProtocolSpecificProperty,
QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery,
};
var storageSpecificData = new STORAGE_PROTOCOL_SPECIFIC_DATA
{
ProtocolType = STORAGE_PROTOCOL_TYPE.ProtocolTypeNvme,
DataType = (uint)STORAGE_PROTOCOL_NVME_DATA_TYPE.NVMeDataTypeLogPage,
ProtocolDataRequestValue = (uint)NVME_LOG_PAGES.NVME_LOG_PAGE_HEALTH_INFO,
ProtocolDataOffset = cbStorageProtocolSpecificDataLength,
ProtocolDataLength = cbNvmeHealthInfoLogLength,
};
StructureToPtr(storagePropertyQuery, lpStoragePropertyQuery, false);
StructureToPtr(storageSpecificData, lpStorageProtocolSpecificData, false);
}
//method for no seek penalty
private static RavenDriveType HasNoSeekPenalty(string sDrive)
{
var hDrive = CreateFileW(sDrive, 0, // No access to drive
FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero);
DEVICE_SEEK_PENALTY_DESCRIPTOR querySeekPenaltyDesc;
bool querySeekPenaltyResult;
try
{
if (hDrive == INVALID_HANDLE_VALUE)
{
var message = GetErrorMessage(Marshal.GetLastWin32Error());
if (Log.IsInfoEnabled)
{
Log.Info("CreateFile failed. " + message);
}
return(RavenDriveType.Unknown);
}
var IOCTL_STORAGE_QUERY_PROPERTY = CTL_CODE(IOCTL_STORAGE_BASE, 0x500, METHOD_BUFFERED, FILE_ANY_ACCESS); // From winioctl.h
var query_seek_penalty = new STORAGE_PROPERTY_QUERY
{
PropertyId = StorageDeviceSeekPenaltyProperty,
QueryType = PropertyStandardQuery
};
querySeekPenaltyDesc = new DEVICE_SEEK_PENALTY_DESCRIPTOR();
uint returnedQuerySeekPenaltySize;
querySeekPenaltyResult = DeviceIoControl(hDrive, IOCTL_STORAGE_QUERY_PROPERTY, ref query_seek_penalty, (uint)Marshal.SizeOf(query_seek_penalty), ref querySeekPenaltyDesc, (uint)Marshal.SizeOf(querySeekPenaltyDesc), out returnedQuerySeekPenaltySize, IntPtr.Zero);
}
finally
{
Win32ThreadsMethods.CloseHandle(hDrive);
}
if (querySeekPenaltyResult == false)
{
var message = GetErrorMessage(Marshal.GetLastWin32Error());
if (Log.IsInfoEnabled)
{
Log.Info("DeviceIoControl failed. " + message);
}
return(RavenDriveType.Unknown);
}
return(querySeekPenaltyDesc.IncursSeekPenalty == false ? RavenDriveType.SSD : RavenDriveType.HDD);
}
public STORAGE_DEVICE_DESCRIPTOR_PARSED_EX StorageGetDeviceProperty()
{
STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY
{
QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery,
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty
};
byte[] res = DeviceIoControlHelper.InvokeIoControlUnknownSize(Handle, IOControlCode.StorageQueryProperty, query);
STORAGE_DEVICE_DESCRIPTOR descriptor = /*Utils.*/ ByteArrayToStruct <STORAGE_DEVICE_DESCRIPTOR>(res, 0);
STORAGE_DEVICE_DESCRIPTOR_PARSED_EX returnValue = new STORAGE_DEVICE_DESCRIPTOR_PARSED_EX
{
Version = descriptor.Version,
Size = descriptor.Size,
DeviceType = descriptor.DeviceType,
DeviceTypeModifier = descriptor.DeviceTypeModifier,
RemovableMedia = descriptor.RemovableMedia,
CommandQueueing = descriptor.CommandQueueing,
VendorIdOffset = descriptor.VendorIdOffset,
ProductIdOffset = descriptor.ProductIdOffset,
ProductRevisionOffset = descriptor.ProductRevisionOffset,
SerialNumberOffset = descriptor.SerialNumberOffset,
BusType = descriptor.BusType,
RawPropertiesLength = descriptor.RawPropertiesLength,
RawDeviceProperties = descriptor.RawDeviceProperties
};
if (returnValue.SerialNumberOffset != 0)
{
returnValue.SerialNumber = ReadNullTerminatedAsciiString(res, (int)returnValue.SerialNumberOffset);
}
if (returnValue.VendorIdOffset != 0)
{
returnValue.VendorId = ReadNullTerminatedAsciiString(res, (int)returnValue.VendorIdOffset);
}
if (returnValue.ProductIdOffset != 0)
{
returnValue.ProductId = ReadNullTerminatedAsciiString(res, (int)returnValue.ProductIdOffset);
}
if (returnValue.ProductRevisionOffset != 0)
{
returnValue.ProductRevision = ReadNullTerminatedAsciiString(res, (int)returnValue.ProductRevisionOffset);
}
return(returnValue);
}
//method for no seek penalty
private static DriveType HasNoSeekPenalty(string sDrive)
{
var hDrive = CreateFileW(sDrive, 0, // No access to drive
FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero);
if (hDrive == null || hDrive.IsInvalid)
{
var message = GetErrorMessage(Marshal.GetLastWin32Error());
if (log.IsDebugEnabled)
{
log.Debug("CreateFile failed. " + message);
}
return(DriveType.Unknown);
}
var IOCTL_STORAGE_QUERY_PROPERTY = CTL_CODE(IOCTL_STORAGE_BASE, 0x500, METHOD_BUFFERED, FILE_ANY_ACCESS); // From winioctl.h
var query_seek_penalty = new STORAGE_PROPERTY_QUERY
{
PropertyId = StorageDeviceSeekPenaltyProperty,
QueryType = PropertyStandardQuery
};
var querySeekPenaltyDesc = new DEVICE_SEEK_PENALTY_DESCRIPTOR();
uint returnedQuerySeekPenaltySize;
var querySeekPenaltyResult = DeviceIoControl(hDrive, IOCTL_STORAGE_QUERY_PROPERTY, ref query_seek_penalty, (uint)Marshal.SizeOf(query_seek_penalty), ref querySeekPenaltyDesc, (uint)Marshal.SizeOf(querySeekPenaltyDesc), out returnedQuerySeekPenaltySize, IntPtr.Zero);
hDrive.Close();
if (querySeekPenaltyResult == false)
{
var message = GetErrorMessage(Marshal.GetLastWin32Error());
if (log.IsDebugEnabled)
{
log.Debug("DeviceIoControl failed. " + message);
}
return(DriveType.Unknown);
}
return(querySeekPenaltyDesc.IncursSeekPenalty == false ? DriveType.SSD : DriveType.HDD);
}
public StorageAccessAlignment GetAlignment(SafeHandle hDevice)
{
StorageAccessAlignment alignment = new StorageAccessAlignment();
SafeAllocHandle <STORAGE_PROPERTY_QUERY> storagePropertyQueryPtr = null;
SafeAllocHandle <STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR> storageAlignmentPtr = null;
try {
STORAGE_PROPERTY_QUERY storagePropertyQuery = new STORAGE_PROPERTY_QUERY {
PropertyId = (uint)STORAGE_PROPERTY_ID.StorageAccessAlignmentProperty,
QueryType = (uint)STORAGE_QUERY_TYPE.PropertyStandardQuery
};
storagePropertyQueryPtr = new SafeAllocHandle <STORAGE_PROPERTY_QUERY>(storagePropertyQuery);
storageAlignmentPtr = new SafeAllocHandle <STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR>();
bool success = DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
storagePropertyQueryPtr, storagePropertyQueryPtr.SizeOf,
storageAlignmentPtr, storageAlignmentPtr.SizeOf,
out uint bytesReturns, IntPtr.Zero);
if (!success || bytesReturns == 0)
{
// Windows XP returns success, byte bytesReturns == 0.
m_Win32Error = Marshal.GetLastWin32Error();
return(null);
}
STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR storageAlignment = storageAlignmentPtr.ToStructure();
alignment.BytesPerCacheLine = (int)storageAlignment.BytesPerCacheLine;
alignment.BytesOffsetForCacheAlignment = (int)storageAlignment.BytesOffsetForCacheAlignment;
alignment.BytesPerLogicalSector = (int)storageAlignment.BytesPerLogicalSector;
alignment.BytesPerPhysicalSector = (int)storageAlignment.BytesPerPhysicalSector;
alignment.BytesOffsetForSectorAlignment = (int)storageAlignment.BytesOffsetForSectorAlignment;
} finally {
if (storagePropertyQueryPtr != null)
{
storagePropertyQueryPtr.Close();
}
if (storageAlignmentPtr != null)
{
storageAlignmentPtr.Close();
}
}
return(alignment);
}
public UInt32 GetPhysicalSectors(string drive)
{
short FILE_ATTRIBUTE_NORMAL = 0x80;
short INVALID_HANDLE_VALUE = -1;
uint GENERIC_READ = 0x80000000;
uint GENERIC_WRITE = 0x40000000;
uint CREATE_NEW = 1;
uint CREATE_ALWAYS = 2;
uint OPEN_EXISTING = 3;
SafeFileHandle handleValue = CreateFile(drive, GENERIC_READ, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
if (handleValue.IsInvalid)
{
//Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
return(0);
}
uint IOCTL_STORAGE_QUERY_PROPERTY = 0x002d1400;
STORAGE_PROPERTY_QUERY storageQuery = new STORAGE_PROPERTY_QUERY();
storageQuery.PropertyId = STORAGE_PROPERTY_QUERY.STORAGE_PROPERTY_ID.StorageAccessAlignmentProperty;
storageQuery.QueryType = STORAGE_PROPERTY_QUERY.STORAGE_QUERY_TYPE.PropertyStandardQuery;
STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR diskAlignment = new STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR();
Int32 read = 0;
if (DeviceIoControl(handleValue, IOCTL_STORAGE_QUERY_PROPERTY, ref storageQuery, Marshal.SizeOf(storageQuery), ref diskAlignment, Marshal.SizeOf(diskAlignment), ref read, IntPtr.Zero))
{
handleValue.Close();
return(diskAlignment.BytesPerPhysicalSector);
}
else
{
handleValue.Close();
return(0);
}
}
public BoolUnknown IncursSeekPenalty(SafeHandle hDevice)
{
SafeAllocHandle <STORAGE_PROPERTY_QUERY> storagePropertyQueryPtr = null;
SafeAllocHandle <STORAGE_DEVICE_SEEK_PENALTY> storageSeekPenaltyPtr = null;
try {
STORAGE_PROPERTY_QUERY storagePropertyQuery = new STORAGE_PROPERTY_QUERY {
PropertyId = (uint)STORAGE_PROPERTY_ID.StorageDeviceSeekPenaltyProperty,
QueryType = (uint)STORAGE_QUERY_TYPE.PropertyStandardQuery
};
storagePropertyQueryPtr = new SafeAllocHandle <STORAGE_PROPERTY_QUERY>(storagePropertyQuery);
storageSeekPenaltyPtr = new SafeAllocHandle <STORAGE_DEVICE_SEEK_PENALTY>();
bool success = DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
storagePropertyQueryPtr, storagePropertyQueryPtr.SizeOf,
storageSeekPenaltyPtr, storageSeekPenaltyPtr.SizeOf,
out uint bytesReturns, IntPtr.Zero);
if (!success || bytesReturns == 0)
{
m_Win32Error = Marshal.GetLastWin32Error();
return(BoolUnknown.Unknown);
}
STORAGE_DEVICE_SEEK_PENALTY storageSeekPenalty = storageSeekPenaltyPtr.ToStructure();
return(storageSeekPenalty.IncursSeekPenalty ? BoolUnknown.True : BoolUnknown.False);
} finally {
if (storagePropertyQueryPtr != null)
{
storagePropertyQueryPtr.Close();
}
if (storageSeekPenaltyPtr != null)
{
storageSeekPenaltyPtr.Close();
}
}
}
/// <summary>
/// Gets the serial number of the specified physical driver.
/// </summary>
/// <param name="DriveName">Name of the disk drive.</param>
public static unsafe string GetSerialNumberOf(string DriveName = "PhysicalDrive0")
{
var SerialNumber = (string)null;
//
// Setup the driver's handlers/settings.
//
var DriverLoader = new KernelServiceLoader();
DriverLoader.SetServiceName("disk");
DriverLoader.SetOwnership(false);
var DriverIo = new DriverIo();
DriverIo.SetSymbolicLink("\\\\.\\" + DriveName);
//
// Initialize the driver interface.
//
using (var Driver = new Driver(new DriverConfig(), DriverLoader, DriverIo))
{
//
// Opens or starts the disk driver.
//
if (!Driver.TryLoad())
{
Console.WriteLine("[*] Failed to load the driver.");
goto End;
}
//
// Connects with the disk driver.
//
if (Driver.IO.TryConnect())
{
var Desc = new STORAGE_DESCRIPTOR_HEADER();
var Query = new STORAGE_PROPERTY_QUERY
{
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty,
QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery
};
//
// Call the disk driver's IRP handler.
//
if (Driver.IO.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), &Desc, Marshal.SizeOf(Desc)))
{
var Allocation = Marshal.AllocHGlobal(Desc.Size);
if (Driver.IO.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), Allocation.ToPointer(), Desc.Size))
{
var DeviceDesc = Marshal.PtrToStructure <STORAGE_DEVICE_DESCRIPTOR>(Allocation);
if (DeviceDesc.SerialNumberOffset != 0)
{
SerialNumber = Marshal.PtrToStringAnsi(IntPtr.Add(Allocation, DeviceDesc.SerialNumberOffset), Desc.Size - DeviceDesc.SerialNumberOffset);
SerialNumber = SerialNumber.Trim('\0');
}
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor.");
}
Marshal.FreeHGlobal(Allocation);
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor size.");
}
}
else
{
// Console.WriteLine("[*] Failed to connect with the driver.");
}
//
// Unload the driver.
// We don't have ownership of the disk driver, so it doesn't really do anything.
//
if (!Driver.TryUnload())
{
Console.WriteLine("[*] Failed to unload the driver.");
goto End;
}
//
// Dispose the driver interface.
//
End :;
}
return(SerialNumber);
}
public static extern bool DeviceIoControl(SafeFileHandle hDevice, uint dwIoControlCode, ref STORAGE_PROPERTY_QUERY lpInBuffer, uint nInBufferSize, ref DEVICE_SEEK_PENALTY_DESCRIPTOR lpOutBuffer, uint nOutBufferSize, ref uint lpBytesReturned, IntPtr lpOverlapped);
/// <summary>
/// Method for no seek penalty
/// </summary>
/// <param name="sDrive"></param>
/// <returns></returns>
public static DriveType HasNoSeekPenalty(string sDrive)
{
SafeFileHandle hDrive = CreateFileW(
sDrive,
0, // No access to drive
FILE_SHARE_READ | FILE_SHARE_WRITE,
IntPtr.Zero,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
IntPtr.Zero);
if (hDrive == null || hDrive.IsInvalid)
{
string message = GetErrorMessage(Marshal.GetLastWin32Error());
//Console.WriteLine("CreateFile failed. " + message);
return(DriveType.Unknown);
}
uint IOCTL_STORAGE_QUERY_PROPERTY = CTL_CODE(
IOCTL_STORAGE_BASE, 0x500,
METHOD_BUFFERED, FILE_ANY_ACCESS); // From winioctl.h
STORAGE_PROPERTY_QUERY query_seek_penalty =
new STORAGE_PROPERTY_QUERY();
query_seek_penalty.PropertyId = StorageDeviceSeekPenaltyProperty;
query_seek_penalty.QueryType = PropertyStandardQuery;
DEVICE_SEEK_PENALTY_DESCRIPTOR query_seek_penalty_desc =
new DEVICE_SEEK_PENALTY_DESCRIPTOR();
uint returned_query_seek_penalty_size;
bool query_seek_penalty_result = DeviceIoControl(
hDrive,
IOCTL_STORAGE_QUERY_PROPERTY,
ref query_seek_penalty,
(uint)Marshal.SizeOf(query_seek_penalty),
ref query_seek_penalty_desc,
(uint)Marshal.SizeOf(query_seek_penalty_desc),
out returned_query_seek_penalty_size,
IntPtr.Zero);
if (query_seek_penalty_result == false)
{
string message = GetErrorMessage(Marshal.GetLastWin32Error());
//Console.WriteLine("DeviceIoControl failed. " + message);
}
hDrive.Close();
if (query_seek_penalty_result == false)
{
return(DriveType.Unknown);
}
if (query_seek_penalty_desc.IncursSeekPenalty == false)
{
//Console.WriteLine("This drive has NO SEEK penalty.");
return(DriveType.SSD);
}
else
{
//Console.WriteLine("This drive has SEEK penalty.");
return(DriveType.Rotational);
}
}
public List <deviceModle> getDevices()
{
List <deviceModle> devices = new List <deviceModle> ();
foreach (var device in new ManagementObjectSearcher(@"SELECT * FROM Win32_DiskDrive").Get())
{
deviceModle thisdevices = new deviceModle();
thisdevices.modleName = device["Model"]?.ToString().Trim();
string diskname = device["DeviceID"].ToString();
thisdevices.PhysicalDriveNumber = int.Parse(diskname.Substring(diskname.Length - 1, 1));
System.IntPtr hDevice = Kernel.CreateFile(diskname,
Kernel.GENERIC_READ | Kernel.GENERIC_WRITE,
Kernel.FILE_SHARE_READ | Kernel.FILE_SHARE_WRITE,
0,
Kernel.OPEN_EXISTING,
0,
0);
STORAGE_PROPERTY_QUERY Query = new STORAGE_PROPERTY_QUERY();
STORAGE_DEVICE_DESCRIPTOR DevDesc = new STORAGE_DEVICE_DESCRIPTOR();
string bustype = "";
uint bytesReturned = 0;
Query.PropertyId = 0;
Query.QueryType = 0;
if (0 != Kernel.DeviceIoControl(hDevice, // device handle
Kernel.IOCTL_STORAGE_QUERY_PROPERTY, // info of device property
ref Query,
(uint)Marshal.SizeOf(Query), // input data buffer
ref DevDesc,
(uint)Marshal.SizeOf(DevDesc), // output data buffer
ref bytesReturned, // out's length
IntPtr.Zero))
{
switch (DevDesc.BusType)
{
case STORAGE_BUS_TYPE.BusTypeUnknown:
bustype = Kernel.DISK_TYPE_UNKNOWN_TEXT;
break;
case STORAGE_BUS_TYPE.BusTypeScsi:
bustype = Kernel.DISKTYPE_SCSI;
break;
case STORAGE_BUS_TYPE.BusTypeAtapi:
bustype = Kernel.DISKTYPE_ATAPI;
break;
case STORAGE_BUS_TYPE.BusTypeAta:
bustype = Kernel.DISKTYPE_ATA;
break;
case STORAGE_BUS_TYPE.BusType1394:
bustype = Kernel.DISKTYPE_1394;
break;
case STORAGE_BUS_TYPE.BusTypeSsa:
bustype = Kernel.DISKTYPE_SSA;
break;
case STORAGE_BUS_TYPE.BusTypeFibre:
bustype = Kernel.DISKTYPE_FIBRE;
break;
case STORAGE_BUS_TYPE.BusTypeUsb:
bustype = Kernel.DISKTYPE_USB;
break;
case STORAGE_BUS_TYPE.BusTypeRAID:
bustype = Kernel.DISKTYPE_RAID;
break;
case STORAGE_BUS_TYPE.BusTypeSata:
bustype = Kernel.DISKTYPE_SATA;
break;
case STORAGE_BUS_TYPE.BusTypeMax:
bustype = Kernel.DISKTYPE_MAX;
break;
case STORAGE_BUS_TYPE.BusTypeNvme:
bustype = Kernel.DISKTYPE_MAX;
break;
default:
break;
}
}
thisdevices.busType = bustype;
devices.Add(thisdevices);
Kernel.CloseHandle(hDevice);
}
return(devices);
}
public static Exception GetDiskDriveId(int id, out string vendorId, out string productId, out string productRevision, out string serialNumber)
{
vendorId = "";
productId = "";
productRevision = "";
serialNumber = "";
// Open handle to specified physical drive.
string lpFileName = string.Format(@"\\.\PhysicalDrive{0}", id);
UInt32 dwDesiredAccess = 0;
UInt32 dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ;
IntPtr lpSecurityAttributes = default(IntPtr);
UInt32 dwCreationDisposition = OPEN_EXISTING;
UInt32 dwFlagsAndAttributes = 0;
IntPtr hTemplateFile = default(IntPtr);
Exception error = null;
var deviceHandle = CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
// If open handle failed then...
if (deviceHandle == null || deviceHandle.IsInvalid)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else
{
// Define and store input parameters for header retrieval.
STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY()
{
PropertyId = 0, QueryType = 0
};
var inputBufferSize = Marshal.SizeOf(query.GetType());
var inputBuffer = Marshal.AllocHGlobal(inputBufferSize);
Marshal.StructureToPtr(query, inputBuffer, true);
uint ioControlCode = IOCTL_STORAGE_QUERY_PROPERTY;
// Define and store output parameters.
var headerBufferSize = Marshal.SizeOf(typeof(STORAGE_DESCRIPTOR_HEADER));
var headerBuffer = Marshal.AllocHGlobal(headerBufferSize);
var headerBytesReturned = default(UInt32);
// Get only header information from the device.
var success = DeviceIoControl(deviceHandle, ioControlCode, inputBuffer, inputBufferSize, headerBuffer, headerBufferSize, ref headerBytesReturned, IntPtr.Zero);
if (!success)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else if (headerBytesReturned != headerBufferSize)
{
error = new InvalidOperationException("Bad header structure declaration");
}
else
{
// Get header data,
var header = (STORAGE_DESCRIPTOR_HEADER)Marshal.PtrToStructure(headerBuffer, typeof(STORAGE_DESCRIPTOR_HEADER));
// Define and store intput parameters for full data retrieval.
var descriptorBufferSize = header.Size;
var descriptorBufferPointer = Marshal.AllocHGlobal(descriptorBufferSize);
var descriptorBytesReturned = default(UInt32);
success = DeviceIoControl(deviceHandle, ioControlCode, inputBuffer, inputBufferSize, descriptorBufferPointer, descriptorBufferSize, ref descriptorBytesReturned, IntPtr.Zero);
if (!success)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else if (headerBytesReturned != headerBufferSize)
{
error = new InvalidOperationException("Bad descriptor structure declaration");
}
else
{
var descriptor = (STORAGE_DEVICE_DESCRIPTOR)Marshal.PtrToStructure(descriptorBufferPointer, typeof(STORAGE_DEVICE_DESCRIPTOR));
byte[] descriptorBuffer = new byte[descriptorBufferSize];
Marshal.Copy(descriptorBufferPointer, descriptorBuffer, 0, descriptorBuffer.Length);
vendorId = GetString(descriptorBuffer, descriptor.VendorIdOffset);
productId = GetString(descriptorBuffer, descriptor.ProductIdOffset);
productRevision = GetString(descriptorBuffer, descriptor.ProductRevisionOffset);
serialNumber = GetString(descriptorBuffer, descriptor.SerialNumberOffset);
}
// Dispose descriptor buffer.
Marshal.FreeHGlobal(descriptorBufferPointer);
}
// Dispose header buffer.
Marshal.FreeHGlobal(headerBuffer);
// Dispose input buffer
Marshal.FreeHGlobal(inputBuffer);
}
// Dispose device handle.
deviceHandle.Dispose();
deviceHandle = null;
return(error);
}
public VolumeDeviceQuery GetStorageDeviceProperty(SafeHandle hDevice)
{
VolumeDeviceQuery volumeDeviceQuery = new VolumeDeviceQuery();
SafeAllocHandle <STORAGE_PROPERTY_QUERY> storagePropertyQueryPtr = null;
SafeAllocHandle <STORAGE_DESCRIPTOR_HEADER> storageDescriptorHeaderPtr = null;
SafeAllocHandle <STORAGE_DEVICE_DESCRIPTOR> storageDeviceDescriptorPtr = null;
try {
STORAGE_PROPERTY_QUERY storagePropertyQuery = new STORAGE_PROPERTY_QUERY {
PropertyId = (uint)STORAGE_PROPERTY_ID.StorageDeviceProperty,
QueryType = (uint)STORAGE_QUERY_TYPE.PropertyStandardQuery
};
storagePropertyQueryPtr = new SafeAllocHandle <STORAGE_PROPERTY_QUERY>(storagePropertyQuery);
// Get the necessary output buffer size
STORAGE_DESCRIPTOR_HEADER storageDescriptorHeader = new STORAGE_DESCRIPTOR_HEADER {
Version = 0,
Size = 0
};
storageDescriptorHeaderPtr = new SafeAllocHandle <STORAGE_DESCRIPTOR_HEADER>(storageDescriptorHeader);
bool success = DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
storagePropertyQueryPtr, storagePropertyQueryPtr.SizeOf,
storageDescriptorHeaderPtr, storageDescriptorHeaderPtr.SizeOf,
out uint bytesReturns, IntPtr.Zero);
if (!success || bytesReturns == 0)
{
m_Win32Error = Marshal.GetLastWin32Error();
return(null);
}
STORAGE_DESCRIPTOR_HEADER storageDescriptorHeaderResult = storageDescriptorHeaderPtr.ToStructure();
storageDeviceDescriptorPtr = new SafeAllocHandle <STORAGE_DEVICE_DESCRIPTOR>((int)storageDescriptorHeaderResult.Size);
success = DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
storagePropertyQueryPtr, storagePropertyQueryPtr.SizeOf,
storageDeviceDescriptorPtr, storageDeviceDescriptorPtr.SizeOf,
out bytesReturns, IntPtr.Zero);
if (!success || bytesReturns == 0)
{
m_Win32Error = Marshal.GetLastWin32Error();
return(null);
}
STORAGE_DEVICE_DESCRIPTOR storageDeviceDescriptor = storageDeviceDescriptorPtr.ToStructure();
if (storageDeviceDescriptor.VendorIdOffset != 0)
{
volumeDeviceQuery.VendorId = storageDeviceDescriptorPtr.ToStringAnsi((int)storageDeviceDescriptor.VendorIdOffset);
}
if (storageDeviceDescriptor.SerialNumberOffset != 0)
{
volumeDeviceQuery.DeviceSerialNumber = storageDeviceDescriptorPtr.ToStringAnsi((int)storageDeviceDescriptor.SerialNumberOffset);
}
if (storageDeviceDescriptor.ProductIdOffset != 0)
{
volumeDeviceQuery.ProductId = storageDeviceDescriptorPtr.ToStringAnsi((int)storageDeviceDescriptor.ProductIdOffset);
}
if (storageDeviceDescriptor.ProductRevisionOffset != 0)
{
volumeDeviceQuery.ProductRevision = storageDeviceDescriptorPtr.ToStringAnsi((int)storageDeviceDescriptor.ProductRevisionOffset);
}
volumeDeviceQuery.RemovableMedia = storageDeviceDescriptor.RemovableMedia;
volumeDeviceQuery.CommandQueueing = storageDeviceDescriptor.CommandQueueing;
volumeDeviceQuery.ScsiDeviceType = (ScsiDeviceType)storageDeviceDescriptor.DeviceType;
volumeDeviceQuery.ScsiDeviceModifier = storageDeviceDescriptor.DeviceTypeModifier;
volumeDeviceQuery.BusType = (BusType)storageDeviceDescriptor.BusType;
} finally {
if (storagePropertyQueryPtr != null)
{
storagePropertyQueryPtr.Close();
}
if (storageDescriptorHeaderPtr != null)
{
storageDescriptorHeaderPtr.Close();
}
if (storageDeviceDescriptorPtr != null)
{
storageDeviceDescriptorPtr.Close();
}
}
return(volumeDeviceQuery);
}
public static Exception GetDiskDriveId(int id, out string vendorId, out string productId, out string productRevision, out string serialNumber)
{
vendorId = "";
productId = "";
productRevision = "";
serialNumber = "";
// Open handle to specified physical drive.
string lpFileName = string.Format(@"\\.\PhysicalDrive{0}", id);
UInt32 dwDesiredAccess = 0;
UInt32 dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ;
IntPtr lpSecurityAttributes = default(IntPtr);
UInt32 dwCreationDisposition = OPEN_EXISTING;
UInt32 dwFlagsAndAttributes = 0;
IntPtr hTemplateFile = default(IntPtr);
Exception error = null;
var deviceHandle = CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
// If open handle failed then...
if (deviceHandle == null || deviceHandle.IsInvalid)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else
{
// Define and store input parameters for header retrieval.
STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY() { PropertyId = 0, QueryType = 0 };
var inputBufferSize = Marshal.SizeOf(query.GetType());
var inputBuffer = Marshal.AllocHGlobal(inputBufferSize);
Marshal.StructureToPtr(query, inputBuffer, true);
uint ioControlCode = IOCTL_STORAGE_QUERY_PROPERTY;
// Define and store output parameters.
var headerBufferSize = Marshal.SizeOf(typeof(STORAGE_DESCRIPTOR_HEADER));
var headerBuffer = Marshal.AllocHGlobal(headerBufferSize);
var headerBytesReturned = default(UInt32);
// Get only header information from the device.
var success = DeviceIoControl(deviceHandle, ioControlCode, inputBuffer, inputBufferSize, headerBuffer, headerBufferSize, ref headerBytesReturned, IntPtr.Zero);
if (!success)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else if (headerBytesReturned != headerBufferSize)
{
error = new InvalidOperationException("Bad header structure declaration");
}
else
{
// Get header data,
var header = (STORAGE_DESCRIPTOR_HEADER)Marshal.PtrToStructure(headerBuffer, typeof(STORAGE_DESCRIPTOR_HEADER));
// Define and store intput parameters for full data retrieval.
var descriptorBufferSize = header.Size;
var descriptorBufferPointer = Marshal.AllocHGlobal(descriptorBufferSize);
var descriptorBytesReturned = default(UInt32);
success = DeviceIoControl(deviceHandle, ioControlCode, inputBuffer, inputBufferSize, descriptorBufferPointer, descriptorBufferSize, ref descriptorBytesReturned, IntPtr.Zero);
if (!success)
{
error = new Win32Exception(Marshal.GetLastWin32Error());
}
else if (headerBytesReturned != headerBufferSize)
{
error = new InvalidOperationException("Bad descriptor structure declaration");
}
else
{
var descriptor = (STORAGE_DEVICE_DESCRIPTOR)Marshal.PtrToStructure(descriptorBufferPointer, typeof(STORAGE_DEVICE_DESCRIPTOR));
byte[] descriptorBuffer = new byte[descriptorBufferSize];
Marshal.Copy(descriptorBufferPointer, descriptorBuffer, 0, descriptorBuffer.Length);
vendorId = GetString(descriptorBuffer, descriptor.VendorIdOffset);
productId = GetString(descriptorBuffer, descriptor.ProductIdOffset);
productRevision = GetString(descriptorBuffer, descriptor.ProductRevisionOffset);
serialNumber = GetString(descriptorBuffer, descriptor.SerialNumberOffset);
}
// Dispose descriptor buffer.
Marshal.FreeHGlobal(descriptorBufferPointer);
}
// Dispose header buffer.
Marshal.FreeHGlobal(headerBuffer);
// Dispose input buffer
Marshal.FreeHGlobal(inputBuffer);
}
// Dispose device handle.
deviceHandle.Dispose();
deviceHandle = null;
return error;
}
