DEC 5.2 String hashen?

[Michael II]

Hallo a.def

ich hatte dir via PN geantwortet.

Öffne ein neues Projekt, setze einen Button aufs Form und kopiere den Text unten rein.

Starte das Programm und klick auf den Button.

Deine exe sieht momentan so aus:
¦FILE EXE TEIL 1¦In EXE nach diesem Text suchen..¦FILE EXE TEIL 2¦

Wenn du den Button drückst, dann wird der Hash Wert h von
¦FILE EXE TEIL 1¦FILE EXE TEIL 2¦
berechnet.

Anschliessend wird eine neue exe md5c.exe erzeugt mit Inhalt:
¦FILE EXE TEIL 1¦<h>¦FILE EXE TEIL 2¦
Anstelle von "In EXE nach diesem Text suchen.." steht also nun der Wert von h in md5c.exe.

Starte md5c.exe. Drücke den Button. md5c.exe berechnet den Hash Wert von
¦FILE EXE TEIL 1¦FILE EXE TEIL 2¦
und liest den Wert von h aus md5c.exe

Die beiden Werte werden in der Zeile "showmessage" miteinander verglichen.

Man kann's sicher kürzer und besser schreiben (und du musst natürlich noch "try finally/except end" einbauen) ...aber es funktioniert.

Delphi-Quellcode:

var
  a : RawByteString = 'In EXE nach diesem Text suchen..';


implementation

{$R *.dfm}


function TByteToHex( b : TBytes ): RawByteString;
var i : integer;
begin
  Result := '';
  for i := 0 to High(b) do
    Result := Result + RawByteString(inttohex( b[i] ));
end;


procedure TForm77.Button1Click(Sender: TObject);
var f2, f : TBytesStream;
    mf, mfc : string;
    hp : int64;
    hashRaw : RawByteString;

begin
  mf := extractfilepath(application.ExeName) + 'md5.exe';
  mfc := extractfilepath(application.ExeName) + 'md5c.exe';

  if copyfile( PChar(application.ExeName), PChar(mf), false ) then
  begin
     f := TBytesStream.Create;
     f.LoadFromFile( mf );
     hp := pos( RawByteString(a), RawByteString(f.Bytes) );
     f2 := TBytesStream.Create;
     f2.Write( f.Bytes[0], hp-1 );
     f2.Write( f.Bytes[hp+length(a)], f.Size - (hp+length(a)) + 1 );

     hashRaw := TByteToHex( System.hash.THashMD5.GetHashBytes( f2 ) );

     showmessage( string(hashraw) + #10 + string(a) +  #10 + (hashraw=a).ToInteger.ToString );

     if extractfilename( application.ExeName ) <> 'md5c.exe' then
     begin
        move( hashRaw[1], f.Bytes[hp-1], length(a) );
        f.SaveToFile( mfc );
     end;
     f.Free;
     close;

     DeleteFile( mf );
  end;
end;

[a.def]

Danke für die Erklärung! Beim ersten f2.Write ist hinten das +1 zuviel glaube ich. Ich habs weggenommen denn sonst wird ein NULL-Zeichen mit verarbeitet das es nicht gibt.

Delphi-Quellcode:

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);
  iPosRawByte := Pos(RawByteString(a), RawByteString(aByteStream.Bytes));

  if iPosRawByte > 0 then
   begin
    aByteStream2 := TBytesStream.Create;
    try
     aByteStream2.Write(aByteStream.Bytes[0], iPosRawByte - 1);
     aByteStream2.Write(aByteStream.Bytes[iPosRawByte + Length(a)], aByteStream.Size - (iPosRawByte + Length(a)));
     aByteStream2.SaveToFile('_STREAM.txt'); // zum test um mir zu zeigen, was in aBytesStream2 vorhanden ist

     hashRaw := TByteToHex(System.hash.THashMD5.GetHashBytes(aByteStream2));

     ShowMessage(string(hashRaw) + #10 + string(a) + #10 + (hashRaw = a).ToInteger.ToString);
    finally
     aByteStream2.Free;
    end;
   end;
 finally
  aByteStream.Free;
 end;

Irgendwo scheint es aber noch ein Problem zu geben. hashRaw ist bei mir D41D8CD98F00B204E9800998ECF8427E, es sollte aber 2708D4849D8E94F1FB0F8145999B632A sein.
Ob da irgendwo was mit der Umwandlung von Byte to Hex schiefgeht?

Edit
mit folgender Zeile klappt es und der Hash ist korrekt. Nur ob das eine schöne Lösung ist?
hashRaw := System.hash.THashMD5.GetHashString(Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes)));

Nur das erneute Auslesen des Hashes funktioniert nicht. Denn wenn ich den RawByteString ersetze, kann ich ja später nicht mehr nach ihm suchen.

[Michael II]

Hallo a.def

1.
wenn du das Programm startest, sind natürlich die Hash Werte voneinander verschieden, denn es wird ja

"In EXE nach diesem Text suchen.." als Hash Wert interpretiert und verglichen mit dem Hash Wert von ¦FILE EXE TEIL 1¦FILE EXE TEIL 2¦.

Wenn du aber die vom Programm erzeugte md5c.exe startest, dann steht anstelle von "In EXE nach diesem Text suchen.." nun der Hash Wert von ¦FILE EXE TEIL 1¦FILE EXE TEIL 2¦. Die Hash Werte sollten nun übereinstimmen.

2.

Zitat:

Beim ersten f2.Write ist hinten das +1 zuviel glaube ich

Nebenbei: Beim ersten f2.write steht am Ende ein -1 und nicht +1 .

Rasch checken: Wie viele Bytes b werden in f2 geschrieben?

b = (hp-1) + (f.Size - (hp+length(a)) + 1) = f.Size-length(a)

Korrekte Länge.

Hast du mit meinem Codete getestet oder mit deinem?

[a.def]

Habe deinen Code genommen und angepasst. Das hier ist mein Code. Ehrlich gesagt verstehe ich noch nicht, wie man TEIL1 und TEIL2 wieder zusammenfügen sollen, wenn am Ende doch ein Hash dazwischen steht.

Delphi-Quellcode:

procedure TForm1.Button6Click(Sender: TObject);
var
 aByteStream, aByteStream2: TBytesStream;
 iPosRawByte: Int64;
 sHash: string;
begin
 // Save hash on the position of RawByteString "a"

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);
  iPosRawByte := Pos(RawByteString(a), RawByteString(aByteStream.Bytes));

  if iPosRawByte > 0 then
   begin
    aByteStream2 := TBytesStream.Create;
    try
     aByteStream2.Write(aByteStream.Bytes[0], iPosRawByte - 1);
     aByteStream2.Write(aByteStream.Bytes[iPosRawByte + Length(a)], aByteStream.Size - (iPosRawByte + Length(a))); // +1 entfernt, da Hash sonst falsch
     // Original: f2.Write( f.Bytes[hp+length(a)], f.Size - (hp+length(a)) + 1 );

     sHash := System.hash.THashSHA2.GetHashString(Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes))); // abgeändert, da Hash sonst ebenfalls falsch
     // Original: hashRaw := TByteToHex( System.hash.THashMD5.GetHashBytes( f2 ) );

     Move(AnsiString(sHash)[1], aByteStream.Bytes[iPosRawByte - 1], Length(a));
     aByteStream.SaveToFile(aFileName);
    finally
     aByteStream2.Free;
    end;
   end;
 finally
  aByteStream.Free;
 end;
end;

Das hier ist meine Prozedur die -nur- dafür da ist den Hash in die Datei zu schreiben.

Erklärung;
ich habe ein kleines Tool, welches NUR dafür da ist die Hashwerte ans Ende von jeder meiner Exe-Dateien zu schreiben.
Ich schiebe dem Tool einfach meine Exe-Dateien in ein Memo, klicke den Button und alle Exen werden angepasst.

[Michael II]

Du schreibst

beim ersten Mal
iPosRawByte - 1

und beim zweiten Mal
aByteStream.Size - (iPosRawByte + Length(a))

Bytes in deinen aByteStream2. Insgesamt also

iPosRawByte - 1 + aByteStream.Size - iPosRawByte - Length(a)

=
aByteStream.Size - 1 - length(a)

Ist nicht schlimm, da du die allermeisten Bytes deiner exe ja berücksichtigst - und weil du es beim Schreiben und Lesen gleich machst.

Ich würde auf TypeCasts wie AnsiString(..) String(..) wenn immer möglich verzichten.

Die Trim Funktion ist soweit ich sehe falsch. Es könnte ja sein, dass in deinem BytesStream vorne oder hinten der Code für das Leerzeichen steht. Mit Trim löschst du diese Leerzeichen Bytes. OK In diesem Anwendungsfall eher nicht [Byte 1 im exe Header ist immer gleich, am Ende der exe?]. Aber wenn du den Code anderswo so verwendest, verlierst du u.U. Infos, bevor du den Hash ermittelst. Also weg damit

Zitat:

Ehrlich gesagt verstehe ich noch nicht, wie man TEIL1 und TEIL2 wieder zusammenfügen sollen, wenn am Ende doch ein Hash dazwischen steht

Diese Teile sind in der "Quell exe" und in der "Ziel exe" identisch. Deshalb "hashen" wir über diese beiden Teile.

[a.def]

Ich verstehe es leider nicht. ich bleibe lieber beim alten System

Das Schreiben/modifizieren verstehe ich.

Was ich aber in keinster Weise verstehe ist, wie ich mit der modifizierten Exe (die sich ja SELBER prüft!) wieder an genau die stelle kommen soll, wo der RawByteString durch den Hash ersetzt wurde.
Denn zum Prüfen müsste ich ja von INHALT1<HASH>INHALT2 den <HASH> entfernen, damit ich INHALT1 INHALT2 hashen kann und mit <HASH> vergleichen kann.
Nur die Position ist mir ja, nachdem mit der Exe ( dem Tool die meine Exen modifiziert) die Programm-Exe ansich modifiziert wurde, nicht mehr bekannt da ich sie nicht mehr finden kann.

[nahpets]

Deshalb hatte ich ja in meinem Beispiel die vier @ davor und dahinter.

Das ist die Kennung der Position.

Du brauchst in der Exe eine Dir bekannte Information, die sagt: Hier hinter steht der Hash.

Oder zwischen diesen beiden steht der Hash, ja nach dem, wie Du es lieber lösen möchtest.

[Michael II]

Und noch etwas:

Mir fällt gerade auf, dass du nun nicht mehr MD5 sondern SHA2 verwendest.

SHA2 Hashs sind länger als MD5. Du musst dies bei deiner Wahl von "a" berücksichtigen.


Im "Fall MD5" wird

a : RawByteString = 'In EXE nach diesem Text suchen..';

in der Ziel exe ersetzt durch sowas wie das hier:

a : RawByteString = 'a8910908bcd9012ba29208210120cd9e';

Wenn du SHA2 verwendest, dann muss dein a doppelt so lang definiert sein.

Wenn du dein a zu kurz wählst, dann überschreibst du Dinge, die du besser stehen lässt .

[Ich habe noch einmal meinen Code gecheckt - und finde keine Fehler. Solltest du meinen Code bei dir laden und laufen lassen und einen Fehler entdecken, dann schreib mir. Danke. Ich verlasse dieses Thema.]

[Michael II]

Zitat:

Nur die Position ist mir ja, nachdem mit der Exe ( dem Tool die meine Exen modifiziert) die Programm-Exe an sich modifiziert wurde, nicht mehr bekannt da ich sie nicht mehr finden kann.

Aber sowas von bekannt. Wenn du md5c.exe startest (aus meinem Beispiel), dann siehst du ja, dass es klappt.

Ich weiss, ich hätte dir zwei Teile anbieten sollten; einen Teil
- "Codiere Hash in die exe" und einen zweiten Teil
- "Prüfe den Hash in der exe".
Didaktisch wäre das so korrekt, aber es wäre weniger Magie dabei.


Wir schreiben ja den Hash Wert aus ¦FILE EXE TEIL 1¦FILE EXE TEIL 2¦ in die neue exe (md5c.exe) an die Position von a.


Schau jetzt noch einmal in den Code an, den ich gepostet habe.

Die md5c.exe macht genau die gleichen Dinge, wie die ursprüngliche exe. Nur dass jetzt in der md5c.exe an Stelle von

a : RawByteString = 'In EXE nach diesem Text suchen..';
sowas drin steht:
a : RawByteString = 'a8910908bcd9012ba29208210120cd9e';


Der Delphi Quellcode von md5c.exe sähe also genau gleich aus wie bei der alten exe bis auf NEU
a : RawByteString = 'a8910908bcd9012ba29208210120cd9e';


Was macht das Programm md5c.exe?
Das neue Programm (md5c.exe) ist ja bis auf den neuen Wert von a absolut identisch mit dem alten. Es sucht also wieder nach dem Wert von a.
Dieses Mal sucht das Programm aber nicht nach 'In EXE nach diesem Text suchen..', sondern nach a='a8910908bcd9012ba29208210120cd9e'. Natürlich wird der Wert gefunden (wir lesen ja den Wert von a und suchen nun wieder genau gleich, wo a in der exe gespeichert ist). Wir kennen also nun die Position von a in der md5c.exe. Wir berechnen den Hash Wert h über den Rest der md5c.exe. Wir vergleichen h mit dem Wert in a. Fertig .

[a.def]

Ach ich glaube ich lasse es jetzt auch sein und belasse es beim Hash am Ende der Datei.

Nur damit ihr wisst wo ich dran bin:
Mein RawByteString: _TESTTESTTEST_1234AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5678_TESTTESTTEST_

Mein Code

Delphi-Quellcode:

procedure TForm1.Button6Click(Sender: TObject);
var
 aByteStream, aByteStream2: TBytesStream;
 iPosRawByte: Int64;
 sHash: string;
begin
 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);
  iPosRawByte := Pos(RawByteString(a), RawByteString(aByteStream.Bytes));

  if iPosRawByte > 0 then
   begin
    iPosRawByte := iPosRawByte + 4;

    aByteStream2 := TBytesStream.Create;
    try
     aByteStream2.Write(aByteStream.Bytes[0], iPosRawByte - 1);
     aByteStream2.Write(aByteStream.Bytes[iPosRawByte + Length(a) - 9], aByteStream.Size - (iPosRawByte + (Length(a) - 9)));

     ShowMessage('"' + Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes)) + '"');
     sHash := System.hash.THashSHA2.GetHashString(Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes)));

     Move(AnsiString(sHash)[1], aByteStream.Bytes[iPosRawByte - 1], Length(a) - 8);
     aByteStream.SaveToFile(aFileName);
    finally
     aByteStream2.Free;
    end;
   end;
 finally
  aByteStream.Free;
 end;
end;

// Das mit dem -8 und -9 ist einfach nur rumexperimentiere da ich keine Ahnung hab wie es richtig geht.

In der Datei kommt an:

Zitat:

_TESTTESTTEST_12340e9b25c3947ef8f165223ac1ab447011cbf6196533678552da 4d19447552cbd5678_TESTTESTTEST_

Am Ende des Hashs steht cbd, korrekt wäre aber cbd1.