Hexwert in Binärdatei suchen und Position ermitteln

[fringer]

Hallo Leute,
ich würde gern in einer binär Datei einen vordefinierten Hexwert suchen (6 bytes) und mir die Position
davon anzeigen lassen.

Da mir hier letztens so gut geholfen wurde, wollte ich wieder fragen ob ich auf dem richtigen
Weg bin.

Hier mal die Theorie:

1. eine Funktion schreiben die Hexwerte in Zeichen umwandelt und in einen String übergibt
2. Binärdatei in einen Stream laden (Tmemorystream oder Tfilestream)
3. Mit pos im Stream nach dem String suchen

Wäre das die richtige Herangehensweise? Oder bin ich da auf dem Holzweg?

Meine Delphiversion ist die Version 7.

Vielen Dank im Voraus.
fringer

[himitsu]

Pos ist eine String-Funktion,
also das Binäre erstmal nach Text umwwandeln. (hier alles nach HEX und du kannst wirklich nach einem HexWert suchen, aber aufpassen wegen halben Werten, also nur ungerade Positionen sind gültig)

und seit Delphi 2009 auch noch aufpassen wegen Unicode (2 Byte pro Zeichen)


oder
Hex nach Binär umwandeln,
für den Vergleich Byteweise oder nach Typen wie Byte, Word, LongWord/Integer oder Int64 casten
oder CompareMem
und dann mit einer Schleife in den Daten suchen (alles Stück für Stück vergleichen)



oder
HxD, wenn nicht selber machen

[KodeZwerg]

Ich gehe so vor

Datei Öffnen und einen Puffer damit füllen
was auch immer ich suchen will nach hexformat umwandeln
in einer loop den puffer[X]+puffer[X]+puffer[X] usw durchforsten lassen,
falls ein teilerfolg am ende vom puffer auftritt, beim nachladen des puffers da weitermachen
puffer mit neuen daten nachladen bis dateiende und immer dateiposition merken
auf diese Weise kontrolliere ich Signaturen die dynamische Positionen haben.

[Mavarik]

Hi!

Also nach Hex-Werten kann man nicht suchen... "Hexwerte" ist kein Type...

Du kannst nach Bytes oder auch nach Zeichen suchen...

Und Du kannst sicherlich Hexwerte in Zeichen $FF -> '$'+'F'+'F' umwandeln...

Bei einem Unicode String hast Du dann im Speicher aber '$'+#0+'F'+#0+'F'+#0 stehen.

Bei 6 Hexwerten ist die Frage der Reihenfolge...

Der Wert(Word) $AABB steht im Speicher $BB,$AA.

Liegen Deine "Hexwerte" in der gleichen Reihenfolge, oder willst Du nach $1A2B3C4D5E6F als Wert suchen?

Naja und dann die Suche ist ganz einfach... Irgendwo musst Du die Werte in einen Puffer laden, falls die Datei zu groß ist um komplett in den Speicher zu passen, ansonsten einfach bei einem TMemoryStream

Mit Memory^ auf die Bytes zugreifen und vergleichen...

Wenn Du die Fragen beantwortest, können wir Dir sicherlich besser helfen!

Mavarik

[fringer]

Hallo,
vielen Dank für die bisherigen Tipps und Infos. Bisher habe ich es noch nicht geschafft zu einer Lösung zu kommen. Bin aber weiter dran
Wie ich schon in diesem Thread http://www.delphipraxis.net/195394-o...ml#post1394939 schrieb, habe ich das letzte mal
vor über 10 Jahren etwas programmiert und viele Dinge die ihr Profis täglich macht fallen mir da doch schwer.

Lange rede kurzer Sinn, hier noch mal meine Problematik:

Ich habe eine xyz.dat Datei, in dieser Datei muss ich eine Zeichenfolge suchen lassen und mir davon die Anfangs-Position ausgeben lassen.

Die Zeichenkette wäre in folgenden Formaten diese:

Ascii/Ansi = XPR0�(
Decimal = 88 80 82 48 0 40
Binary = 01011000 01010000 01010010 00110000 00000000 00101000
Hex = 58 50 52 30 00 28

Meine Datei habe ich in ein TMemorystream geladen.
Dann habe ich versucht die Zeichenfolge in ein Array (Ansistring) zu laden. Aber so richtig klappt das alles noch nicht. Und wichtig ist mir
vor allem die Position in der Datei damit ich den Memorystream von dieser Stelle aus weiterverarbeiten kann.

Wenn ihr mir da wieder mit etwas Pseudocode unter die Arme greifen könntet wäre das klasse.

Vielen Dank schon mal.
fringer

[brechi]

Wenn du die Datei komplett in den Speicher laden kannst (ungetestet):

Delphi-Quellcode:

function Search(_Stream: TStream): Boolean;
var
  data: array of Byte;
  search: array of Byte;
  i: int64;
  j: int64;
  fnd: Boolean;
begin
  // daten sind im stream
  _Stream.Position := 0;
  Result := False;
  if _Stream.Size = 0 then
    Exit; // -->
  SetLength(data, _Stream.Size);
  if _Stream.read(data[0], _Stream.Size) <> _Stream.size then
    raise Exception.Create('Fehler beim Lesen der Daten');
  
  SetLength(search, 6);
  search[0] := $58;
  search[1] := $50;
  search[2] := $52;
  search[3] := $30;
  search[4] := $00;
  search[5] := $28;

  for i := Low(Data) to High(Data) - Length(search) + 1 do begin
    fnd := True;
    for j := Low(search) to High(Search) do begin
      if data[i] <> search[j] then begin
        fnd := False;
        break; // -->
      end;
    end; 
    if fnd then begin
      Result := True;
      _Stream.Position := i;
      Exit; // ->
    end;
  end;
end;

[HolgerX]

Hmm..

Zitat von fringer:

ich würde gern in einer binär Datei einen vordefinierten Hexwert suchen (6 bytes) und mir die Position
davon anzeigen lassen.

Würde hier nicht TFileStream besser sein, da mann dann nicht die ganze, eventuell GB große Datei zunächst in einen MemoryStream oder Buffer laden müsste?

Bei kleinen zu durchsuchenden Daten (eventuell schon direkt im Speicher vorhanden) würde die direkte Suche im Memory mit MemoryStream natürlich deutlich performanter sein, da mann dann ohne Read und Positionierung direkt den Speicher per Pointer an CompareMem gegen kann...

[himitsu]

Alles im Speicher ist einfacher. (mehr als 500 MB werden seine Dateien wohl nicht sein)
Beim stückchenweisem Einlesen muß man beachten, dass Übergreifend gesucht werden muß, also eine Hälfte der Suchdaten kann in einem Block sein und der Rest im nachfolgenden Block.

[p80286]

Ich hab da was uraltes ausgegraben was mit Ansichar von #0 .. #255 umgehen kann.

Delphi-Quellcode:

(***************************************************************************)
(* Stringsuche in Anlehnung an Boyer Moore                                 *)
(***************************************************************************)
(* 1.0  Adaption an 32-Bit Pascal                                2000/06/23*)
(***************************************************************************)
unit boymoore32;

interface
{Alle String-Typen sind klassische Pascal-Strings: Array [0..255] of char!}
{Dies entspricht unter Delphi dem shortstring mit der Definition ist man auf der sicheren Seite}
{Der Array in dem gesucht wird ist 64K groß (noch) }
{ Die "alten" Typen word etc werden noch an 32-Bit Gepflogenheiten angepasst}
{ !!!! Es gibt nur einen Sucharray   !!!           }
type
  sucharraytyp= packed array [0..255] of byte; {packed um Lücken zu vermeiden}
var
  sucharray   : sucharraytyp;

function INITSUCHARR(suchstring:shortstring):boolean;
(*  die 16-Bit version arbeitet mit 16Bit Wörtern
function FINDESTR(sptr:pointer;slang:word;suchstring:shortstring):word;
   die 32-Bit Version mit 32-Bit Integern*)

function FINDESTR(bptr:pointer;blang:integer;suchstring:shortstring):integer;

implementation
function INITSUCHARR(suchstring:shortstring):boolean;
var
  j : word;
begin
  {----- jedem ASCII-Wert die Länge des suchstr zuweisen ------------}
  fillchar(sucharray,sizeof(sucharray),length(suchstring));
  {---- umgekehrt indizieren n...1 !!!!! ----------------------------}
  if length(suchstring)>0 then begin
    INITSUCHARR:=true;
    for j:=1 to length(suchstring) do begin
      sucharray[byte(suchstring[j])]:=length(suchstring)-j;
      sucharray[byte(suchstring[j])]:=sucharray[byte(suchstring[j])];
    end;
  end
  else
    INITSUCHARR:=false;
end;

function FINDESTR(bptr:pointer;blang:integer;suchstring:shortstring):integer;
type
  srt =packed array [1..$FFFF] of byte;
  srtc=packed array [1..$FFFF] of char;  { fürs debugging }
var
  bi  : integer;     { Index des Source Integer für 32Bit!}
  ssi : integer;     { Index Suchstr    Integer für 32Bit!}
  ssl : integer;     { Länge suchstr    Integer für 32Bit!}
begin
  ssl:=length(suchstring);
  if ssl>blang then                    { Source ist zu klein }
    FINDESTR:=-1                       { nicht gefunden }
  else begin
    bi :=ssl;                          { erste Vergleichspos ist ende SuchS }
    ssi:=ssl;
    repeat
      if sucharray[srt(bptr^)[bi]]>0 then
        inc(bi,sucharray[srt(bptr^)[bi]])
      else begin
        ssi:=ssl;
        repeat
          dec(bi,1);
          dec(ssi,1);
        until (ssi<1) or (srt(bptr^)[bi]<>byte(suchstring[ssi]));
        if ssi>0 then
          inc(bi,ssl-(ssi-1));
      end;
    until (bi>blang) or (ssi<1);
    { Ergebnis für 0-Basierte Arrays}
    if ssi<1 then FINDESTR:=bi
    else FINDESTR:=-1;
  end;
end;
end.

Gruß
K-H

[fringer]

Vielen Dank für die vielen weiteren Antworten.

Die Funktion von @HolgerX funktioniert soweit. Aber leider nicht mit einem Memorystream bzw. wenn dann die "Nullen" im Stream nicht mitgezählt werden.
Ich werde trotzdem noch einmal versuchen einen Lösungsweg zu finden aber vielleicht ist das ganze auch eine Nummer zu hoch für mich.
Das ganze ist doch wesentlich komplexer als ich dachte.

fringer