...enden die Fragen nie?

Option Explicit
 
'*****************************************************************
' Module for performing Direct Read/Write access to disk sectors
'
' Written by Arkadiy Olovyannikov (ark@fesma.ru)
'
' formated, cutted, fixed and commented by rm_code
'*****************************************************************
 
Private Const FILE_BEGIN = 0                ' file begin at byte 0
 
'function for reading from a drive (only NT)
Public Function DirectReadDriveNT(ByVal sDrive As String, ByVal iStartSec As _
  Long, ByVal iOffset As Long, ByRef ret() As Byte, Optional ByVal cBytes As _
  Long = -1) As Boolean
    Dim hDevice As Long, nSectors As Long, nRead As Long, BytesPerSector As Long
    Dim abBuff() As Byte, abResult() As Byte
    Dim sd As SECURITY_ATTRIBUTES
 
    'get the size of a disk sector in bytes
    If Not GetSectorSize(sDrive, BytesPerSector) Then Exit Function
 
    If cBytes = -1 Or cBytes < 1 Then cBytes = BytesPerSector
 
    'get the number of sectors to read
    nSectors = Int((iOffset + cBytes - 1) / BytesPerSector) + 1
 
    'open the drive
    hDevice = CreateFile("\\.\" & UCase(Left(sDrive, 1)) & ":", _
                         GENERIC_READ Or GENERIC_WRITE, _
                         FILE_SHARE_READ Or FILE_SHARE_WRITE, _
                         sd, OPEN_EXISTING, 0&, 0&)
 
    'check for a valid drive handle
    If hDevice = INVALID_HANDLE_VALUE Then Exit Function
 
    'set the filepointer to the first sector we want to read
    SetFilePointer hDevice, iStartSec * BytesPerSector, 0, FILE_BEGIN
 
    'prepare the buffers
    ReDim abResult(cBytes - 1)
    ReDim abBuff(nSectors * BytesPerSector - 1)
 
    'read the sectors and close the handle to the drive
    ReadFile hDevice, abBuff(0), UBound(abBuff) + 1, nRead, 0&
    CloseHandle hDevice
 
    'copy the bytes from the read buffer to the result buffer...
    CopyMemory abResult(0), abBuff(iOffset), cBytes
 
    '... and return it
    ret = abResult
    DirectReadDriveNT = True
End Function
 
'function for writing to a drive (only NT)
Public Function DirectWriteDriveNT(ByVal sDrive As String, ByVal iStartSec As _
  Long, ByVal iOffset As Long, ByVal sWrite As String) As Boolean
    Dim hDevice As Long, nRead As Long, nSectors As Long, BytesPerSector As Long
    Dim sd As SECURITY_ATTRIBUTES
    Dim abBuff() As Byte, ab() As Byte
 
    'get the size of a disk sector in bytes
    If Not GetSectorSize(sDrive, BytesPerSector) Then Exit Function
 
    'get the number of sectors to read
    nSectors = Int((iOffset + Len(sWrite) - 1) / BytesPerSector) + 1
 
    'open the drive
    hDevice = CreateFile("\\.\" & UCase(Left(sDrive, 1)) & ":", _
                         GENERIC_READ Or GENERIC_WRITE, _
                         FILE_SHARE_READ Or FILE_SHARE_WRITE, _
                         sd, OPEN_EXISTING, 0&, 0&)
 
    'check for a valid drive handle
    If hDevice = INVALID_HANDLE_VALUE Then Exit Function
 
    'fill the write buffer with the data from the sectors we want to overwrite,
    'because we have the option to start writing from an offset
    DirectReadDriveNT sDrive, iStartSec, 0, abBuff, nSectors * BytesPerSector
    ab = StrConv(sWrite, vbFromUnicode)
 
    'add the data to write to the writebuffer
    CopyMemory abBuff(iOffset), ab(0), Len(sWrite)
 
    'set the filepointer to the first sector we want to write to
    SetFilePointer hDevice, iStartSec * BytesPerSector, 0, FILE_BEGIN
 
    'lock the drive for writing
    LockFile hDevice, LoWord(iStartSec * BytesPerSector), _
                      HiWord(iStartSec * BytesPerSector), _
                      LoWord(nSectors * BytesPerSector), _
                      HiWord(nSectors * BytesPerSector)
 
    'write it!
    DirectWriteDriveNT = WriteFile(hDevice, abBuff(0), UBound(abBuff) + 1, _
      nRead, 0&)
 
    'make sure everything was written
    FlushFileBuffers hDevice
 
    'unlock the drive
    UnlockFile hDevice, LoWord(iStartSec * BytesPerSector), _
                        HiWord(iStartSec * BytesPerSector), _
                        LoWord(nSectors * BytesPerSector), _
                        HiWord(nSectors * BytesPerSector)
 
    'and clean up a little bit
    CloseHandle hDevice
End Function

Public Function ReadBootSector(sDrive As String, sDestFile As String) As Boolean
    On Error GoTo ErrH
 
    Dim ret() As Byte
    Dim FF As Byte: FF = FreeFile
 
    If Not DirectReadDriveNT(sDrive, 0, 1, ret) Then Exit Function
 
    Open sDestFile For Binary As #FF
        Put #FF, , ret
    Close #FF
 
    ReadBootSector = True
 
ErrH:
End Function
 
Public Function WriteBootSector(sDrive As String, sBootImage As String) As _
  Boolean
    On Error GoTo ErrH
 
    Dim FF As Byte: FF = FreeFile
    Dim sRet As String
    Dim ret() As Byte
 
    Open sBootImage For Binary As #FF
        ReDim ret(FileLen(sBootImage )) As Byte
        Get #FF, , ret
    Close #FF
 
    sRet = StrConv(ret, vbUnicode)
 
    WriteBootSector = DirectWriteDriveNT(sDrive, 0, 0, ret)
 
ErrH:
End Function

...enden die Fragen nie?

Option Explicit
 
Public Declare Function GetDiskFreeSpace Lib "kernel32.dll" Alias _
  "GetDiskFreeSpaceA" ( _
    ByVal lpRootPathName As String, lpSectorsPerCluster As Long, _
    lpBytesPerSector As Long, lpNumberOfFreeClusters As Long, _
    lpTotalNumberOfClusters As Long _
) As Long
 
Public Declare Function DeviceIoControl Lib "kernel32" ( _
    ByVal hDevice As Long, ByVal dwIoControlCode As Long, _
    ByRef lpInBuffer As Any, ByVal nInBufferSize As Long, _
    ByRef lpOutBuffer As Any, ByVal nOutBufferSize As Long, _
    ByRef lpBytesReturned As Long, ByRef lpOverlapped As OVERLAPPED _
) As Long
 
Public Declare Function CreateFile Lib "kernel32" Alias "CreateFileA" ( _
    ByVal lpFileName As String, ByVal dwDesiredAccess As Long, _
    ByVal dwShareMode As Long, ByRef lpSecurityAttributes As _
    SECURITY_ATTRIBUTES, _
    ByVal dwCreationDisposition As Long, ByVal dwFlagsAndAttributes As Long, _
    ByVal hTemplateFile As Long _
) As Long
 
Public Declare Function WriteFile Lib "kernel32" ( _
    ByVal hFile As Long, lpBuffer As Any, _
    ByVal nNumberOfBytesToWrite As Long, _
    lpNumberOfBytesWritten As Long, ByVal lpOverlapped As Long _
) As Long
 
Public Declare Function ReadFile Lib "kernel32" ( _
    ByVal hFile As Long, lpBuffer As Any, _
    ByVal nNumberOfBytesToRead As Long, lpNumberOfBytesRead As Long, _
    ByVal lpOverlapped As Long _
) As Long
 
Public Declare Function LockFile Lib "kernel32" ( _
    ByVal hFile As Long, ByVal dwFileOffsetLow As Long, _
    ByVal dwFileOffsetHigh As Long, ByVal nNumberOfBytesToLockLow As Long, _
    ByVal nNumberOfBytesToLockHigh As Long _
) As Long
 
Public Declare Function UnlockFile Lib "kernel32" ( _
    ByVal hFile As Long, ByVal dwFileOffsetLow As Long, _
    ByVal dwFileOffsetHigh As Long, ByVal nNumberOfBytesToUnlockLow As Long, _
    ByVal nNumberOfBytesToUnlockHigh As Long _
) As Long
 
Public Declare Function SetFilePointer Lib "kernel32" ( _
    ByVal hFile As Long, ByVal lDistanceToMove As Long, _
    lpDistanceToMoveHigh As Long, ByVal dwMoveMethod As Long _
) As Long
 
Public Declare Function GetVersionEx Lib "kernel32" Alias "GetVersionExA" ( _
        lpVersionInformation As OSVERSIONINFOEX _
) As Long
 
Public Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" ( _
    Destination As Any, Source As Any, ByVal length As Long _
)
 
Public Declare Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" ( _
    ByVal nDrive As String _
) As Long
 
Public Declare Function FlushFileBuffers Lib "kernel32" ( _
    ByVal hFile As Long _
) As Long
 
Public Declare Function CloseHandle Lib "kernel32" ( _
    ByVal hObject As Long _
) As Long
 
Public Type SECURITY_ATTRIBUTES
    nLength As Long
    lpSecurityDescriptor As Long
    bInheritHandle As Long
End Type
 
Public Type OSVERSIONINFOEX
    dwOSVersionInfoSize As Long
    dwMajorVersion As Long
    dwMinorVersion As Long
    dwBuildNumber As Long
    dwPlatformId As Long
    szCSDVersion As String * 128
End Type
 
Public Type OVERLAPPED
    Internal As Long
    InternalHigh As Long
    offset As Long
    OffsetHigh As Long
    hEvent As Long
End Type
 
Public Const VER_PLATFORM_WIN32s = 0
Public Const VER_PLATFORM_WIN32_WINDOWS = 1
Public Const VER_PLATFORM_WIN32_NT = 2
 
Public Const FILE_ATTRIBUTE_NORMAL = &H80  ' ?
Public Const GENERIC_READ = &H80000000     ' Generic read flag
Public Const GENERIC_WRITE = &H40000000    ' Generic write flag
Public Const FILE_READ_ACCESS = &H1        ' Readrights
Public Const FILE_WRITE_ACCESS = &H2       ' Writerights
Public Const FILE_SHARE_READ = &H1         ' shared read rights
Public Const FILE_SHARE_WRITE = &H2        ' shared write rights
Public Const OPEN_EXISTING = 3             ' open an existing file
Public Const INVALID_HANDLE_VALUE = -1&    ' invalid handle
 
Public Function LoWord(ByVal nDWord As Long) As Long
  LoWord = CLng("&H" & Left$(Right$("00000000" & Hex$(nDWord), 8), 4))
End Function
 
Public Function HiWord(ByVal nDWord As Long) As Long
  HiWord = CLng("&H" & Right$(Right$("00000000" & Hex$(nDWord), 8), 4))
End Function
 
Public Function GetSectorSize(ByVal drv As String, ByRef lSize As Long) As _
  Boolean
    Dim lSpC As Long, lBpS As Long, lNoFC As Long, lTNoC As Long
 
    If GetDiskFreeSpace(Left$(drv, 1) & ":", lSpC, lSize, lNoFC, lTNoC) <> 0 _
      Then _
        GetSectorSize = True
End Function

  'open the drive
  hDevice = CreateFile("\\.\" & UCase(Left(sDrive, 1)) & ":", _
            GENERIC_READ Or GENERIC_WRITE, _
            FILE_SHARE_READ Or FILE_SHARE_WRITE, _
            sd, OPEN_EXISTING, 0&, 0&)
 
  'check for a valid drive handle
  If hDevice = INVALID_HANDLE_VALUE Then Exit Function

...enden die Fragen nie?