Sektoren auslesen

[webby]

Hallo,
wie kann ich von einem Datenträger gezielt einen Sektor auslesen.
Ich möchte nämlich dann herausfinden, ob der entsprechende Sektor fehlerhaft ist.

[sakura]

Für welches Betriebssystem und was für ein Dateiformat (NTFS, FAT16, FAT32, ...) Ist schon wichtig dass zu wissen, ist schliesslich immer wieder anders ;)

...:cat:...

[webby]

Also wenn ich in die Windows API Sparte poste, werde ich als Betriebssystem Windows benutzen :) (oder hab ich die falsche Sparte erwischt?!).
Und die meisten Disketten nutzen ja FAT32.

[Luckie]

Du hast nur "Datenträger" geschrieben und das kann auch eine Festplatte oder CD-ROM sein. :wink:

[sakura]

Bei Disketten muss ich leider passen, sorry ;)

...:cat:...

[jbg]

Zitat:

Zitat von webby

Also wenn ich in die Windows API Sparte poste, werde ich als Betriebssystem Windows benutzen

Das ist toll, aber welches Windows? Windows 9x/ME oder NT/2000/XP.
Für NT-basierte ist es um einiges einfacher als für 9x-basierte.

ab WinNT 3.5 (also kein 9x/ME)

Delphi-Quellcode:

uses Windows;
type
  TDiskGeometry = packed record
    Cylinders: Int64;
    MediaType: Integer;
    TracksPerCylinder: DWORD;
    SectorsPerTrack: DWORD;
    BytesPerSector: Integer; // wichtig für die Reservierung des Buffer-Speichers
  end;

  TRawDrive = record
    DiskGeometry: TDiskGeometry;
    Handle: THandle;
  end;

var
  IOCTL_DISK_GET_DRIVE_GEOMETRY = $00070000;
  FSCTL_LOCK_VOLUME = $00090018;
  FSCTL_UNLOCK_VOLUME = $0009001C;

function RawOpenDrive(DriveLetter: Char): TRawDrive;
var num: Cardinal;
begin
  FillChar(Result, SizeOf(TRawDrive), 0);

  Result.Handle := CreateFile(PChar('\\.\' + DriveLetter + ':'),
                       GENERIC_READ or GENERIC_WRITE,
                       FILE_SHARE_READ or FILE_SHARE_WRITE,
                       nil,
                       OPEN_EXISTING,
                       0,
                       0);
  if Result.Handle = INVALID_HANDLE_VALUE then RaiseLastOSError;

 // Laufwerk für andere sperren
  if not DeviceIoControl(Result, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, num, nil) then
    RaiseLastOSError;

 { Disk-Geometry ermitteln. Vor allem ist das Feld BytesPerSector wichtig, da nur vielfache Bytes gelesen werden können. Ist also BytesPerSector z.B: 512 und man will nur 1 Byte lesen, muss man 512 Bytes lesen. }
  if not DeviceIoControl(h, IOCTL_DISK_GET_DRIVE_GEOMETRY, nil, 0, @Result.DiskGeometry,
                         SizeOf(TDiskGeometry), num, nil) then
    RaiseLastOSError; 
end;

procedure RawCloseDrive(var RawDrive: TRawDrive);
var num: Cardinal;
begin
  DeviceIoControl(RawDrive.Handle, FSCTL_UNLOCK_VOLUME, nil, 0, nil, 0, num, nil);
  CloseHandle(RawDrive.Handle);
  RawDrive.Handle := 0;
end;

procedure RawReadSectors(const RawDrive: TRawDrive; var Buf; Count: Integer);
var num: Cardinal;
begin
  if not ReadFile(RawDrive.Handle, Buf, Count * RawDrive.DiskGeometry.BytesPerSector, num, nil) then
    RaiseLastOSError;
end;

procedure RawWriteSectors(const RawDrive: TRawDrive; var Buf; Count: Integer);
var num: Cardinal;
begin
  if not WriteFile(RawDrive.Handle, Buf, Count * RawDrive.DiskGeometry.BytesPerSector, num, nil) then
    RaiseLastOSError;
end;

Hier fehlt noch das RawSeek, jedoch brauchte ich bei meinem Diskettenkopierprogramm dieses nicht und habe es somit auch nicht programmiert. Die benötigte API Funktion wäre SetFilePointer. Hier ist aber auch wieder darauf zu achten, dass nur an Sektorgrenzen gesprungen werden kann.

[webby]

Zitat:

Zitat von Luckie

Du hast nur "Datenträger" geschrieben und das kann auch eine Festplatte oder CD-ROM sein. :wink:

Stimmt, sorry, ich war davon überzeugt, dass ich Diskette geschrieben hätte...
Tja so kann man sich täuschen... ;)


Achso, stimmt ja in solche Sachen gehen 9x und NT anders ran.
Ne ich habe (leider) Windows XP Home Edition

@jbg:
Danke ich werde mir später den Code nochmal genau anschauen!

[MadMax]

Das ist genau das Programm das ich brauche.

Frage:
Muss das Prog als Konsolen-Anwendung kompiliert werden?

Das erste Problem tritt schon bei der Variablen Definition auf Delphi 5.0 checkt das irgendwie nicht.

Code:

var
  IOCTL_DISK_GET_DRIVE_GEOMETRY = $00070000;
  FSCTL_LOCK_VOLUME = $00090018;
  FSCTL_UNLOCK_VOLUME = $0009001C;

[Fehler] Project2.dpr(19): ',' oder ':' erwartet, aber '=' gefunden
[Fehler] Project2.dpr(19): '..' erwartet, aber ';' gefunden

usw....

[Luckie]

Jeder aufmerksame Programmierer sieht, dass es sich hier:

Delphi-Quellcode:

IOCTL_DISK_GET_DRIVE_GEOMETRY = $00070000;

um keine Variabledeklaration, sondern um eine Konstantendeklaration handelt. Und jeder clevere Programmierer, kommt dann auf die Idee und ersetzt das var durch const. :wink:

War wohl der ScripptKiddie-CopyAndPaste-Schutz und du bist voll reingetappt in die Falle. :mrgreen:

[nice]

nabend erstmal

ich hätt mal ne frage zu dem source:

Delphi-Quellcode:

if not DeviceIoControl(Result, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, num, nil) then 
    RaiseLastOSError;

bei mir kommt bei der result ein fehler,es wäre eine Trawdrive - ist ja klar deklariert
er will aber an der stelle eine cardinal

wie kann ich das beheben ?

oder gibts ne schönere variante sektoren einer cd auszulesen(als rückgabe reicht auch defekt : true/false)
soll ein kleiner "kopierschutz" werden

[Assarbad]

1. Ein Handle ist ein Cardinal-Wert und der erste Parameter ist eben das Handle zu dem Laufwerk. Ist ja auch wunderbar im Beispiel ersichtlich.

2. Wenn das dein Kopierschutz ist, ist er popelig einfach zu knacken. Versuch es besser erst garnicht, oder denk dir was besseres aus. Frag am besten mal Hagen (aka negaH).

[nice]

also muss ich das einfach nur mit ner anderen variable ersetzen,die ein cardinal ist

und so popelig ist der garnicht
hab den sheep-test und copykiller3reg leicht kombiniert und als erste session auf ne cd in mode 1 gepackt - alle meine laufwerke weigern sich,das weiter als sektor 200 einzulesen
und ich hab keine billigen/schlechten laufwerke
nen yamaha f1,nen plex premium und ein tosh1612 (ausserdem lg-gsa4040b und ricoh mp5125)
siehe http://www.nethands.de/pys/show.php4?user=doenerking

das programm (soll monopoly werden) kommt auf session 2

[Assarbad]

Ich spreche auch nicht davon, daß irgendein Laufwerk das lesen kann - aber man kann es im Handumdrehen knacken!

Result.Handle := CreateFile(...

dann hast du das Handle in Result.Handle ... dann kannst du exakt _dieses_ Handle and DeviceIoControl weiterreichen.

[The-X]

Zitat:

Zitat von webby

Also wenn ich in die Windows API Sparte poste, werde ich als Betriebssystem Windows benutzen :) (oder hab ich die falsche Sparte erwischt?!).
Und die meisten Disketten nutzen ja FAT32.

^^ Disketten? FAT32??? soweit ich weiss nicht!

Disketten benutzen AFAIK FAT12 oder FAT16 ?

[nice]

Zitat:

Ich spreche auch nicht davon, daß irgendein Laufwerk das lesen kann - aber man kann es im Handumdrehen knacken!

nur mal interessehalber
wie denkst du dir,kann man den umgehen (ohne den quelltext zu haben)

[nice]

habs immer noch nicht geschafft - es kommt ein fehler beim rawreadsektors - keine idee mehr
es geht nur um die letzten zeilen

oder hat jemand nen test - eingabe des sektors und laufwerk - ausgabe:defekt ja/nein

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TDiskGeometry = packed record
    Cylinders: Int64;
    MediaType: Integer;
    TracksPerCylinder: DWORD;
    SectorsPerTrack: DWORD;
    BytesPerSector: Integer; // wichtig für die Reservierung des Buffer-Speichers
  end;

  TRawDrive = record
    DiskGeometry: TDiskGeometry;
    Handle: THandle;
  end;

  TForm1 = class(TForm)
    Ergebnis: TLabel;
    Sektor: TEdit;
    OK: TButton;
    procedure SektorKeyPress(Sender: TObject; var Key: Char);
    procedure OKClick(Sender: TObject);

  private
    { Private-Deklarationen }
  public

    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  sektor1:Integer;
  sektordaten:String;
  handle:cardinal;
  drive:TRawDrive;
const
  IOCTL_DISK_GET_DRIVE_GEOMETRY = $00070000;
  FSCTL_LOCK_VOLUME = $00090018;
  FSCTL_UNLOCK_VOLUME = $0009001C;

implementation

{$R *.dfm}


function RawOpenDrive(DriveLetter: Char): TRawDrive;
var num,h: Cardinal;
begin
h:=0;
  FillChar(Result, SizeOf(TRawDrive), 0);

  Result.Handle := CreateFile(PChar('\\.\' + DriveLetter + ':'),
                       GENERIC_READ or GENERIC_WRITE,
                       FILE_SHARE_READ or FILE_SHARE_WRITE,
                       nil,
                       OPEN_EXISTING,
                       0,
                       0);
  if Result.Handle = INVALID_HANDLE_VALUE then RaiseLastOSError;

// Laufwerk für andere sperren
if not DeviceIoControl(h, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, num, nil) then
RaiseLastOSError;

{ Disk-Geometry ermitteln. Vor allem ist das Feld BytesPerSector wichtig, da nur vielfache Bytes gelesen werden können. Ist also BytesPerSector z.B: 512 und man will nur 1 Byte lesen, muss man 512 Bytes lesen. }
 if not DeviceIoControl(Handle,IOCTL_DISK_GET_DRIVE_GEOMETRY, nil, 0,@Result.DiskGeometry,SizeOf(TDiskGeometry), num, nil) then
  RaiseLastOSError;
end;

procedure RawCloseDrive(var RawDrive: TRawDrive);
var num: Cardinal;
begin
  DeviceIoControl(RawDrive.Handle, FSCTL_UNLOCK_VOLUME, nil, 0, nil, 0, num, nil);
  CloseHandle(RawDrive.Handle);
  RawDrive.Handle := 0;
end;

procedure RawReadSectors(const RawDrive: TRawDrive; var Buf; Count: Integer);
var num: Cardinal;
begin
  if not ReadFile(RawDrive.Handle, Buf, Count * RawDrive.DiskGeometry.BytesPerSector, num, nil) then
    RaiseLastOSError;
end;

procedure RawWriteSectors(const RawDrive: TRawDrive; var Buf; Count: Integer);
var num: Cardinal;
begin
  if not WriteFile(RawDrive.Handle, Buf, Count * RawDrive.DiskGeometry.BytesPerSector, num, nil) then
    RaiseLastOSError;
end;

procedure TForm1.SektorKeyPress(Sender: TObject; var Key: Char);
var sektorstring:String ;
begin
if key = #13 then begin
sektorstring := sektor.Text;
sektor1 :=  StrToInt(sektorstring);
end;
end;

procedure TForm1.OKClick(Sender: TObject);
begin
Drive:=RawOpenDrive('d'); //das mach ich später variabel,jetzt reicht erstmal laufwerk d zum testen
RawReadSectors(Drive,0,sektor1)  //(Fehler)unit1.pas(111):konstantenobjektkann nicht als var-parameter weitergegeben werden
//das soll noch folgen,aber nur temporär : Ergebnis.Caption:=sektordaten;
end;

end.

[Christian Seehase]

Moin Nice,

Zitat:

Zitat von nice

es kommt ein fehler beim rawreadsektors

Aha, und welcher?

[nice]

sorry,hab ich in die kommentare unten geschrieben

Delphi-Quellcode:

RawReadSectors(Drive,0,sektor1)  //(Fehler)unit1.pas(111):konstantenobjektkann nicht als var-parameter weitergegeben werden

[Christian Seehase]

Moin Nice,

ach so, ich dachte während des Programmablaufes.

Dann schau Dir doch mal die Deklaration und den Aufruf an:
Der zweite Parameter ist als var deklariert, ergo kannst Du dort keine Konstante (in diesem Falle 0) angeben.
Ausserdem habe ich so meine Zweifel, dass der Aufruf von ReadFile ohne Angabe eines Buffers für die gelesenen Daten, funktioniert.

[nice]

ach so - danke

also geb ich dort ne variable rein,die den buffer spielt
hab gedacht,das wär die buffergröße

dann müsst ich doch bald damit fertig sein

[nice]

Also ich konnte das Problem jetzt isolieren:

Delphi-Quellcode:

function RawOpenDrive(DriveLetter: Char): TRawDrive; 
var num,h: Cardinal;
begin
  h:=0;
  FillChar(Result, SizeOf(TRawDrive), 0);

  Handle := CreateFile(PChar('\\.\' + DriveLetter + ':'),
                       GENERIC_READ or GENERIC_WRITE,
                       FILE_SHARE_READ or FILE_SHARE_WRITE,
                       nil,
                       OPEN_EXISTING,
                       0,
                       0);
  Result.Handle := Handle;
  if Result.Handle = INVALID_HANDLE_VALUE then RaiseLastOSError;

  // Laufwerk für andere sperren
  if not DeviceIoControl(h, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, num, nil) then
  RaiseLastOSError;

  { Disk-Geometry ermitteln. Vor allem ist das Feld BytesPerSector wichtig, da nur vielfache Bytes gelesen werden können. Ist also BytesPerSector z.B: 512 und man will nur 1 Byte lesen, muss man 512 Bytes lesen. }
  if not DeviceIoControl(Handle,IOCTL_DISK_GET_DRIVE_GEOMETRY, nil, 0,@Result.DiskGeometry,SizeOf(TDiskGeometry), num, nil) then
    RaiseLastOSError;
end;

Wenn ich als DriveLetter 'C' übergeb müsste
es ja theoretisch klappen, nur kommt dann

Zitat:

Zitat von Windows

---------------------------
Systemfehler. Code: 6.
Das Handle ist ungültig.
---------------------------
OK
---------------------------

an der Zeile

Delphi-Quellcode:

if not DeviceIoControl(Handle,IOCTL_DISK_GET_DRIVE_GEOMETRY, nil, 0,@Result.DiskGeometry,SizeOf(TDiskGeometry), num, nil) then
    RaiseLastOSError;

Was ich nicht verstehe, da ja dieses Handle weiter oben geprüft und annerkannt wird... :wiejetzt:

[Christian Seehase]

Moin Nice,

welche Variable enthält denn nun das Handle?
h oder handle?

Das geht aus Deinem Code nämlich nicht genau hervor.

Am Besten setzt Du mal einen Breakpoint auf die DeviceIOControl Zeile und prüfst mal den Inhalt der dort als Handle übergebenen Variablen.

[APP]

Hallo,
ich hätte da noch eine Frage zu CreateFile:

Delphi-Quellcode:

 Handle := CreateFile(PChar('\\.\' + DriveLetter + ':'),

Laut PSDK ist '\\?\' der UNC Präfix für einen Filenamen, ist dann auch '\\.\' zulässig?

Ausserdem steht im PSDK unter Driveletter z.B. 'C:\', in obigem Beispiel würde der Driveletter '\\.\C:' sein, ist das auch erlaubt?

[nice]

sorry,das war,weil wir getestet haben

handle soll das handle sein,h war nur tempörär zum fehlersuchen eingesetzt

werd ich mal testen(wahrscheinlich aber net gleich morgen)

@app - wenn die frage an mich war

mit nem ? haben wirs auch getestet - leider ohne erfolg

[Christian Seehase]

Moin Armin,

ja diese Schreibweise ist, übrigens gemäss PSDK ;-), auch möglich.
Schau Dir mal den Abschnitt unter "Physical disks and volumes" an.