DEC 5.2 String hashen?

[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 :glaskugel: 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 :thumb:.

[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.

[nahpets]

Deine A-Reihe ist "nur" 63 A lang. Müssten das nicht 64 A sein?

[a.def]

Wenn du bei mir um die Ecke wohnen würdest, würde ich dir ein Bier ausgeben.
So dumm wie ich mich anstelle, so dumm bin ich wohl auch :wall:

Ist der Rest denn so in Ordnung? Speziell dieses Herumhantier mit +4, -9 und -8?

Hier mein erstes Ergebnis.

Delphi-Quellcode:

 iHashLengthInBytes = 64;
 aPrefixSuffixLen: Byte = 4;
 a: RawByteString = '1234';
 b: RawByteString = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';

Datei einlesen, Hash bilden und in die Datei an die Stelle von RawByteString speichern

Delphi-Quellcode:

var
 aByteStream, aByteStream2: TBytesStream;
 iPosRawByte: Int64;
 sHash: string;
 c: RawByteString;
begin
 // This code adds a hash of the original file content to the destination files position of RawByteString

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);

  c := a + b + a;
  iPosRawByte := Pos(RawByteString(c), RawByteString(aByteStream.Bytes));
  if iPosRawByte > 0 then
   begin
    iPosRawByte := iPosRawByte + Length(a);

    aByteStream2 := TBytesStream.Create;
    try
     aByteStream2.Write(aByteStream.Bytes[0], iPosRawByte - 1);
     aByteStream2.Write(aByteStream.Bytes[iPosRawByte + Length(c) - (aPrefixSuffixLen * 2 + 1)], aByteStream.Size - (iPosRawByte + (Length(c) - (aPrefixSuffixLen * 2 + 1))));
     sHash := System.Hash.THashSHA2.GetHashString(Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes)));

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

Datei einlesen und den Hash des Inhalts (ohne RawByteString) bilden

Delphi-Quellcode:

var
 aByteStream: TBytesStream;
 iPosRawByte, iPosEx: Int64;
 sTmp, sContent: string;
begin
 // This code reads the original file content and calculates the hash

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);

  iPosRawByte := Pos(RawByteString(a), RawByteString(aByteStream.Bytes));
  if iPosRawByte > 0 then
   begin
    iPosRawByte := iPosRawByte + Length(a);
    iPosEx := Pos(RawByteString(a), RawByteString(aByteStream.Bytes), iPosRawByte + 1);

    // Hier bin ich auf String umgestiegen, da ich nicht weiß wie man Bytes aus TBytesStream löscht
    sTmp := Trim(TEncoding.ANSI.GetString(aByteStream.Bytes));
    sContent := Copy(sTmp, 0, iPosRawByte - 1);
    sContent := sContent + Copy(sTmp, iPosEx, Length(sTmp));

    ShowMessage(sContent);
   end;
 finally
  aByteStream.Free;
 end;
end;

Hash auslesen, der an Position des RawByteStrings gespeichert ist

Delphi-Quellcode:

var
 aByteStream: TBytesStream;
 iPosRawByte: Int64;
begin
 // This code reads the hash added at the position of RawByteString

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);

  iPosRawByte := Pos(RawByteString(a), RawByteString(aByteStream.Bytes));
  if iPosRawByte > 0 then
   begin
    iPosRawByte := iPosRawByte + Length(a);

    aByteStream.Position := iPosRawByte - 1;
    aByteStream.Read(aByteStream.Bytes[0], iHashLengthInBytes);

    ShowMessage(Trim(TEncoding.ANSI.GetString(aByteStream.Bytes)));
   end;
 finally
  aByteStream.Free;
 end;
end;

Denkst du, das ist so "OK"? Ja, das ist viel Copy&Paste aber anders wüsste ich nicht wie es klappen soll.

[Michael II]

Hallo a.def

schau dir nach deinen nächsten Ferien dann nochmal an, wie du den Hash Wert ins File schreibst. Es ist echt keine Zauberei.

Wenn du den Hash Wert ans Ende des Files schreiben willst, dann ist es natürlich einfacher. [ Aber jemand der deine exe abändern will, sieht sofort, dass am Ende was steht und...]

So geht's [du musst den Code natürlich noch absichern - ich mach's mit Absicht nicht, damit du das Wesentliche siehst]:

Hash Wert ans Ende des Files schreiben:

Delphi-Quellcode:

procedure SchreibeHashWertAnFileEnde( filename : string );
var s : string;
    f : TStringStream;
begin
    f := TStringStream.Create;
   try
    f.LoadFromFile( filename );
    s := System.hash.THashMD5.GetHashString( f.ReadString( f.Size ));
    f.WriteString( s );
    f.SaveToFile( filename );
   finally
    f.Free;
   end;
end;

Hash Wert überprüfen:

Delphi-Quellcode:

function PruefeHashWert( filename : string ) : boolean;
var HashWertAmEndeDesFiles , HashWertVomFile : string;
    f : TStringStream;
begin
    f := TStringStream.Create;
   try
    f.LoadFromFile( filename );
    HashWertVomFile := System.hash.THashMD5.GetHashString( f.ReadString( f.Size-32 ));
    HashWertAmEndeDesFiles := f.ReadString( 32 );
   finally
    f.Free;
   end;
    Result := HashWertAmEndeDesFiles = HashWertVomFile;
end;

Beispiel:

Delphi-Quellcode:

procedure TForm79.Button1Click(Sender: TObject);
var fn : string;
begin
  fn := 'C:\Users\Michael\Documents\Embarcadero\Studio\Projekte\Win32\Debug\Project29.exe';
  SchreibeHashWertAnFileEnde( fn );
  if PruefeHashWert( fn ) then ShowMessage( 'OK' ) else showmessage('Error');
end;

Ich hoffe das hilft.

Gruss
M

[a.def]

Danke für die Hilfe. Ein paar Seiten vorher hatte ich meine Unit schon einmal vorgestellt die genau das auch macht :P Mein letztes Problem war nur das Setzen des Hashes mitten in die Datei.
Meine Primitive Lösung dafür ist

Delphi-Quellcode:

var
 aPrefixSuffixLen: Byte = 4;
 iHashLengthInBytes = 64;
 a: RawByteString = '1234';
 b: RawByteString = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';

function doHashAction(aHashAction: THashAction): string;
var
 aByteStream, aByteStream2: TBytesStream;
 iPosRawByte, iPosEx: Int64;
 sHash, sTmp, sContent: string;
 sTmpRawByte, c: RawByteString;
begin
 Result := '';

 if not FileExists(aFileName) then
  Exit;

 aByteStream := TBytesStream.Create;
 try
  aByteStream.LoadFromFile(aFileName);

  case aHashAction of
   THashAction.addHashToFile:
    begin
     c := a + b + a;
     sTmpRawByte := c;
    end
  else
   sTmpRawByte := a;
  end;

  iPosRawByte := Pos(RawByteString(sTmpRawByte), RawByteString(aByteStream.Bytes));
  if iPosRawByte > 0 then
   begin
    iPosRawByte := iPosRawByte + Length(a);

    case aHashAction of
     THashAction.addHashToFile:
      begin
       // This code adds a hash of the original file content to the destination files position of RawByteString
       // ==============================================================================================================================================
       aByteStream2 := TBytesStream.Create;
       try
        aByteStream2.Write(aByteStream.Bytes[0], iPosRawByte - 1);
        aByteStream2.Write(aByteStream.Bytes[iPosRawByte + Length(c) - (aPrefixSuffixLen * 2 + 1)], aByteStream.Size - (iPosRawByte + (Length(c) - (aPrefixSuffixLen * 2 + 1))));
        sHash := System.Hash.THashSHA2.GetHashString(Trim(TEncoding.ANSI.GetString(aByteStream2.Bytes)));

        Move(AnsiString(sHash)[1], aByteStream.Bytes[iPosRawByte - 1], Length(c) - aPrefixSuffixLen * 2);
        aByteStream.SaveToFile(aFileName);
       finally
        aByteStream2.Free;
       end;
       // ==============================================================================================================================================
      end;
     THashAction.getHashedFileContent:
      begin
       // This code reads the original file content and calculates the hash
       // ==============================================================================================================================================
       iPosEx := Pos(RawByteString(a), RawByteString(aByteStream.Bytes), iPosRawByte + 1);

       sTmp := Trim(TEncoding.ANSI.GetString(aByteStream.Bytes));
       sContent := Copy(sTmp, 0, iPosRawByte - 1);
       sContent := System.Hash.THashSHA2.GetHashString(sContent + Copy(sTmp, iPosEx, Length(sTmp)));

       Result := sContent;
       ShowMessage(Result);
       // ==============================================================================================================================================
      end;
     THashAction.getAddedHash:
      begin
       // This code reads the hash added at the position of RawByteString
       // ==============================================================================================================================================
       aByteStream.Position := iPosRawByte - 1;
       aByteStream.Read(aByteStream.Bytes[0], iHashLengthInBytes);

       Result := Trim(TEncoding.ANSI.GetString(aByteStream.Bytes, 0, iHashLengthInBytes));
       ShowMessage(Result);
       // ==============================================================================================================================================
      end;
     THashAction.doCompareHashes:
      begin
       // ==============================================================================================================================================
       ShowMessage(BoolToStr(doHashAction(THashAction.getHashedFileContent) = doHashAction(THashAction.getAddedHash), True));
       // ==============================================================================================================================================
      end;
    end;
   end;
 finally
  aByteStream.Free;
 end;
end;

Delphi-Quellcode:

 // Hash hinzufügen
 doHashAction(THashAction.addHashToFile);

 // Inhalt gehasht auslesen
 doHashAction(THashAction.getHashedFileContent);

 // Hinzugefügten Hash auslesen
 doHashAction(THashAction.getAddedHash);

 // Selftest ausführen
 doHashAction(THashAction.doCompareHashes);

[Zacherl]

Zitat:

Zitat von Michael II (Beitrag 1370078)

Wenn du den Hash Wert ans Ende des Files schreiben willst, dann ist es natürlich einfacher. [ Aber jemand der deine exe abändern will, sieht sofort, dass am Ende was steht und...]

Naja, letztlich ist es ja eh eine Spielerei. Wenn ich die Anwendung modifizieren will, finde ich auch mit Leichtigkeit die Stelle, an der auf Korrektheit des hinterlegten Hashs geprüft wird. Diese Bedingung negiere ich jetzt einfach im Assembly und schon ist der ganze Zauber ausgehebelt. Das ist in den meisten Fällen tatsächlich ein 1-Byte Patch, den selbst Anfänger auf diesem Gebiet innerhalb von ein paar Minuten vornehmen können.

[a.def]

Zitat:

Das ist in den meisten Fällen tatsächlich ein 1-Byte Patch, den selbst Anfänger auf diesem Gebiet innerhalb von ein paar Minuten vornehmen können.

Ich behaupte einfach mal, dass das aus der Luft gegriffen ist.

Ich mache diese Spielerei aus zwei Gründen:
1) ich bin dumm und will lernen
2) es gibt Webseiten die mein Programm geklaut haben und bieten es nun modifiziert selber an

Klar, ein Zertifikat wäre hier die Lösung denke ich. Aber das ist unglaublich teuer (Notar und blaa)

[Michael II]

Also Zacherl hat voll Recht.

Wenn du die Abfrage nicht verschleierst, dann ist man durch, wenn man wie hier die Bedingung "stimmt der Hashwert noch" einfach aushebelt.

Als kleine Knobelei könntest du ja deine Abfrage etwas verstecken und Zacherl dann mal deine exe übergeben ;-).

... und die fünf Minuten stoppen.

[ Und dein Programm sollte dann nicht einfach ausgeben "Ich wurde gehackt" sondern zum Beispiel wenn es ein Spiel ist - einfach schlechter mitspielen. ]

[a.def]

Eine Abfrage verschleiern? Höre ich zum ersten mal, dass das überhaupt möglich ist.

Was ich mir jetzt darunter vorstelle:
- mehrere Abfragen statt nur eine
- ein paar mal Strings herumschupsen
- spezielle Datentypen
?