//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; }