DEC 5.2 String hashen?

[a.def]

Ich bin dir wirklich sehr dankbar für alles. Aber leider funktioniert dein Code bei mir nicht.
Für folgendes erhalte ich auch nur Salat

Delphi-Quellcode:

 // _TEST_TEST_D36E844639D6B4B9ADAF9A11C2ABF841CCE43E94C57539C03CC9524545DD8E8D
 ShowMessage( TEncoding.ANSI.GetString(
    GetSHA1HashFromFile(aFileName, [0, -64])
   )
   );

Deine Lösung ist meiner deutlich überlegen das ist klar. Aber ich denke ich bleibe einfach bei meiner. Ich verstehe sie und kann dran rumbasteln wenn was nicht funktioniert.

[nahpets]

Ein Hash ist kein lesbarere Text, sondern schlicht eine mehr oder weniger lange Bytefolge (landläufig als Salat bezeichnet).

[a.def]

Ich lass das jetzt einfach so. Es funktioniert was will ich denn mehr?
Ist mir jetzt ehrlich gesagt auch zu sehr ein HeckMeck den String da noch in irgendwas anderes umzuwandeln und was weiß ich noch alles.

[Michael II]

Zitat von a.def:

Ich lass das jetzt einfach so. Es funktioniert was will ich denn mehr?
Ist mir jetzt ehrlich gesagt auch zu sehr ein HeckMeck den String da noch in irgendwas anderes umzuwandeln und was weiß ich noch alles.

Es ist gerade umgekehrt. SHA1 liefert 20 Bytes und diese 20 Bytes werden dann typischerweise (wenn du den Wert in irgend einer Arbeit o.ä. druckst) als hex Wert dargestellt.

Wenn du dir also deine Bytes lieber hex anschaust, dann wandle sie doch einfach um:

Delphi-Quellcode:

function TBytesToHex( b : TBytes ) : RawByteString;
var i : integer;
begin
  Result := '';
  for i := 0 to length(b)-1 do Result := Result + inttohex(b[i]);
  Result := lowercase(Result);
end;

[a.def]

Ob SHA1 2 MD5 ist doch egal. Ging mir nur darum, ob da auch 64 Bytes landen, wenn der Hash in der lesbaren Version auch 64 Bytes lang ist. Verstehe halt noch nicht wie "lang" der Salat wirklich ist weil der manchmal kürzer, manchmal länger aussieht als die lesbare Version

[himitsu]

Und ein Salt kann natürlich beliebig groß sein, außer bei Hash-/Verschlüsselungsfunktionen, die einen Salt mit fester Länge erfordern.
Ein Salt ist einfach nur ein "beliebiger" Startwert, mit dem man quasi den Hash initialisiert, damit bei selben Eingangsstrings nicht der selbe Ausgangshash raus kommt, also z.B. das selbe Passwort in verschiedenen Systemen nicht den selben Hash hat und man es so auch mit Rückrechnen/Rainbowtables nicht so leicht hat, um ein passendes Equivalent zu finden.

Wordpress z.B. nutzt einen von der Database separat gespeicherten globalen Salt, für alle Passwörter.
Alternativ kann man auch zu jedem Hash einen eigenen Salt generieren und beim/im Hash hinterlegen.

Zitat von Michael II:

Wenn du dir also deine Bytes lieber hex anschaust, dann wandle sie doch einfach um:

Delphi-Quellcode:

function TBytesToHex( b : TBytes ) : RawByteString;
var i : integer;
begin
  Result := '';
  for i := 0 to length(b)-1 do Result := Result + inttohex(b[i]);
  Result := lowercase(Result);
end;

BinToHex?

[Michael II]

Zitat von a.def:

Mh Ok ich verstehe. Das heißt Bytes Array ist immer von der Länge her die Hälfte vom Hex.
Ich gucke morgen nochmal rein und gucke, ob ich was ändern kann.

Kann ich dafür TByteStream behalten oder ist TFileStream ein Muss?

Wenn du den in einem Byte gespeicherten Wert im hex System interpretieren und als Zeichenkette speichern willst, dann benötigst du pro Byte 2 Zeichen (aus {0..9,A..B} ).

Wenn du den in einem Byte gespeicherten Wert im binären System interpretieren und als Zeichenkette speichern willst, dann benötigst du pro Byte 8 Zeichen ( aus {0..1} ).


TBytesStream oder TFileStream?
(siehe auch weiter oben)
Du willst mit Daten, welche in einem File enthalten sind arbeiten.
TBytesStream kann Daten aufnehmen, welche als Bytes interpretiert werden. Via LoadFromFile kannst du die Daten aufnehmen, welche in einem File enthalten sind.
TFileStream kann keine Daten aufnehmen, sondern gibt dir nur die Möglichkeit (via read/write/..) auf die Daten eines Files zuzugreifen. (Der Datenspeicher ist also hier quasi deine Festplatte o.ä..)

Da du für die Berechnung von SHA1, MD5 Hashs nicht alle Daten (Filedaten) aufs Mal benötigst, musst du auch nicht alle aufs Mal einlesen.

Nimm wie in den Meldungen weiter oben erwähnt TFileStream. Dann hast du deine Daten auf der Platte und liest jeweils nur soviel Daten ein, wie du gerade benötigst.


Und noch kurz zu der Verwendung von trim(..) in deinem Code.
Wenn du für eine beliebige Datei einen Hash Wert berechnen willst, dann darfst du trim nicht verwenden.

Delphi-Quellcode:

daten : TBytes;
a1 : ansistring;
...
... 
a1 := trim( TEncoding.ANSI.GetString( daten ) );

Falls zum Beispiel daten[0] den Wert 32 enthält, dann entspricht dies nach TEncoding.ANSI.GetString dem Leerzeichen und mit trim(..) schneidest du dieses Leerzeichen ab. Wenn du nun über a1 "hashst", dann ermittelst du somit nicht den Hash von daten. [Wenn du TFileStream verwenden wirst und deine exe stückweise einliest (und jeweils die Hash Update Methode aufrufst), dann denk daran: Nicht trimmen .]

Und wenn du's nicht selbst schreiben willst: Du kannst ja 1:1 den weiter oben geposteten Code verwenden fürs Schreiben und Checken des SHA1/MD5 Hashs.

Ich glaube, du hast nun alles, was du benötigst. Ich habe längst fertig .

[Daniel]

Zitat von Michael II:

Ich glaube, du hast nun alles, was du benötigst. Ich habe längst fertig .

"a.def" ist wohl ebenfalls fertig und hat auf eigenen Wunsch das Forum verlassen.
Ich mache daher mal zu.

[Michael II]

Zitat von a.def:

Ich bin dir wirklich sehr dankbar für alles. Aber leider funktioniert dein Code bei mir nicht.
Für folgendes erhalte ich auch nur Salat

Delphi-Quellcode:

 // _TEST_TEST_D36E844639D6B4B9ADAF9A11C2ABF841CCE43E94C57539C03CC9524545DD8E8D
 ShowMessage( TEncoding.ANSI.GetString(
    GetSHA1HashFromFile(aFileName, [0, -64])
   )
   );

Du machst einen Fehler SHA1 liefert 160Bit/20Byte Werte. Du musst also
hash := GetSHA1HashFromFile( filename, [0,-21] );
berechnen, wenn du den Hash Wert des Files ohne den angehängten (20 Byte) Hash Wert berechnen willst.

So geht's:

SHA1 ans Ende des Files schreiben durch Aufruf von
procedure SchreibeSHA1HashAnsEndeDesFiles( const filename : string );

Delphi-Quellcode:

procedure HashAnsEndeDesFilesSchreiben( filename : string; hash : TBytes );
var f : TFileStream;
begin
  f := TFileStream.Create( filename, fmOpenWrite );
 try
  f.Position := f.Size;
  f.Write( hash[0], length( hash ) );
 finally
  f.Free;
 end;
end;


procedure SchreibeSHA1HashAnsEndeDesFiles( const filename : string );
var hash, hash2 : TBytes;
begin
  hash := System.hash.THashSHA1.GetHashBytesFromFile( filename ); // Delphi system.hash
  // hash2 := GetSHA1HashFromFile( filename , [] ); // oder wir verwenden "unsere" SHA1 Funktion
  HashAnsEndeDesFilesSchreiben( filename, hash );
end;

Den Hashwert am Ende des Files überprüfen:
function PruefeSHA1HashAmEndeDesFiles( const filename : string ) : boolean;

Delphi-Quellcode:

function LiesHashAmEndeDesFiles( const filename : string; len : integer ) : TBytes;
var f : TFileStream;
begin
  f := TFileStream.Create( filename, fmOpenRead );
 try
  f.Position := f.Size - len ;
  SetLength( Result, len );
  f.Read( Result, len );
 finally
  f.Free;
 end;
end;

function PruefeSHA1HashAmEndeDesFiles( const filename : string ) : boolean;
var hashAmFileEnde, hash : TBytes;
begin
  hash := GetSHA1HashFromFile( filename, [0,-21] ); // SHA1 erzeugt 160bit (20Byte) Werte
  hashAmFileEnde := LiesHashAmEndeDesFiles( filename, 20 );
  Result := CompareMem( hash, hashAmFileEnde, 20 );
end;

Testen:

Delphi-Quellcode:

procedure pruefen_SHA1;
var filename : string;
    allesok : boolean;
begin
  filename := 'C:\Users\Michael\Desktop\1GB.txt';

  // Ans Fileende schreiben:
  SchreibeSHA1HashAnsEndeDesFiles( filename );
  // Prüfen, ob der HashWert OK ist:
  allesok := PruefeSHA1HashAmEndeDesFiles( filename );

  ShowMessage( 'Check File : ' + allesok.ToInteger.ToString );
end;

[a.def]

Ganz dumme Frage:

wenn ich den String-Hash direkt speichere und er sagen wir mal 64 Byte lang ist, wieviele Byte nimmt denn sein Äquivalent der "Salat" ein. Ebenefalls exakt 64 Byte?
Weil im Editor sieht das irgendwie kürzer aus.