DEC 6.1 generelle Fragen

[DieDolly]

Frage 1:
Ich habe einen TBytesStream den ich vorher mit einer anderen Unit von jemand anderen erfolgreich hashen konnte.
Mit DEC funktioniert das nicht mehr. Kompilieren funktioniert aber ausführen nicht. Es kommt eine Fehlermeldung.

Zitat:

---------------------------
Anwendungsfehler
---------------------------
Exception EReadError in Modul Test.exe bei 0006D4F5.

Stream-Lesefehler.

Was mache ich falsch?

Delphi-Quellcode:

function MD5Stream(const Stream: TMemoryStream): string;
var
 Hash: THash_MD5;
begin
 Hash := THash_MD5.Create;
 try
  Result := string(Hash.CalcStream(Stream, Stream.Size, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

ich füttere das wie gesagt mit einem TBytesStream. Vorher lief es immer aber ich glaube ich habe MD5Stream falsch implementiert.

Frage 2:
ich habe eine Art Wrapper geschrieben, den ich für MD5 und SHA256 nutzen kann. Die Dateien sind, danke der wundervollen Umsetzung von DEC (das ist gut!), quasi gleich. Es muss nur THash_MD5 durch THash_SHA256 ausgetauscht werden. Das heißt aber auch viel doppelter Code.

Wie kann man das hier verallgemeinern? Etwa so habe ich das, aber aufgeteilt auf 2 Dateien. Ich würde das gerne alles in einer Datei haben, dann hat man aber trotzdem noch doppelten Code.

Delphi-Quellcode:

type
 TDEC_Functions = record
 public
  class function MD5String(const Text: string): string; static;
  class function SHA256String(const Text: string): string; static;
 end;

implementation

class function TDEC_Functions.MD5String(const Text: string): string;
var
 Hash: THash_MD5;
begin
 Hash := THash_MD5.Create;
 try
  Result := string(Hash.CalcString(RawByteString(Text), TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function TDEC_Functions.SHA256String(const Text: string): string;
var
 Hash: THash_SHA256;
begin
 Hash := THash_SHA256.Create;
 try
  Result := string(Hash.CalcString(RawByteString(Text), TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

Ist es irgendwie möglich das so zu verallgemeinern, dass die beiden public-Funktionen eine Basis-Funktion aufrufen, vielleicht so?

Delphi-Quellcode:

type
 TDEC_Functions = record
 private
  class function Base_Hash(const Text: string; const Hash-methode: ...): string;
 public
  class function MD5String(const Text: string): string; static;
  class function SHA256String(const Text: string): string; static;
 end;

implementation

class function TDEC_Functions.Base_Hash(const Text: string; const Hash-methode: ...): string;
begin
 Result :=
end;

class function TDEC_Functions.MD5String(const Text: string): string;
begin
 Result := Base_Hash(Text, THash_MD5);
end;

class function TDEC_Functions.SHA256String(const Text: string): string;
begin
 Result := Base_Hash(Text, THash_SHA256);
end;

[TurboMagic]

Bist du sicher, dass der Stream sich am Anfang befindet wenn du ihn übergibst?
Wenn du das mittels Debugger ausführst, bekommst du da bessere Info drüber
wo es genau knallt?

[DieDolly]

Zitat:

ByteStream.Position := 0;

hat das Problem gelöst. Danke!

[TurboMagic]

Und wie, wenn ich fragen darf?

[DieDolly]

Indem ich die Zeile (ByteStream.Position := 0;) hinzugefügt habe. Die hatte ich vorher nicht, bevor ich MD5Stream auzfgerufen habe.

[TurboMagic]

Welche "Zeil"?

[DieDolly]

War ein Tippfehler. Die Zeile zum zurücksetzen des Streams auf 0 hat bei mir komplett gefehlt. Jetzt ist sie drin und es funktioniert.
Ich habe noch eine zweite, letzte Frage hinzugefügt. Ich habe versucht das über TDECHash aus DECHashBase zu lösen aber das ist als Parameter inkompatibel wenn man THash_MD5 oder etwas anderes übergeben möchte.

[TurboMagic]

Ich glaube dass das geht, bin aber gerade nicht am PC.
Stichwort wäre Metaklasse als Parameter...
Dann kannst du Instanzen beider Klassen übergeben.
Evtl. mal den Klassenregistrierungsmechanismus anschauen,
der könnte in die Richtung gehen...

[DieDolly]

Bin schon überfordert, sorry.

[Aviator]

Das was du meinst/suchst nennt sich Polymorphie. Vielleicht kannst du mit dem Begriff etwas anfangen bzw. dir zusätzliche Infos anlesen und zusammensuchen. Wichtig wäre hier, dass du eine gemeinsame Basisklasse von allen Ver-/Ent-/Hashing-Verfahren findest, die noch alle Methoden die du benötigst zur Verfügung stellst. Gibt es die nicht, musst du auf zwei Methoden ausweichen die du dann als

Delphi-Quellcode:

overload

deklarieren könntest.

[DieDolly]

Zitat:

Wichtig wäre hier, dass du eine gemeinsame Basisklasse von allen Ver-/Ent-/Hashing-Verfahren findest, die noch alle Methoden die du benötigst zur Verfügung stellst.

Das habe ich versucht. Ich dachte wenn ich bis runter auf TDECHash gehe, ist das die gemeinsame Basisklasse aber das erzeugt eine AV beim Ausführen.

[Aviator]

Ich habe jetzt nur mal schnell in GitHub direkt in den Sourcen geschaut. Versuch mal die

Delphi-Quellcode:

THashBaseMD4

Klasse. Die sieht mir eigentlich nach der passenden Basisklasse aus. Mit

Delphi-Quellcode:

TDECHash

bist du ja schon fast ganz oben angekommen.

[DieDolly]

Gerade auch schon versucht.

Delphi-Quellcode:

function X(Hash: THashBaseMD4): string;
begin
...
 Result := Hash.CalcString('123');
...
end;

showmessage(X(THash_MD5));

Zitat:

E2010 Inkompatible Typen: 'THashBaseMD4' und 'class of THash_MD5'

Ansonsten lege ich mir einfach ein type THashMethods = (MD5, SHA256);, übergebe als parameter THashMethods.XYZ und gucke dann in in der Funktion mittels case was übergeben wurde.
Eine sehr schlechte Umsetzung wäre das aber.

[Aviator]

Naja du musst schon eine Instanz und nicht die Klasse übergeben. Ich habe mal schnell ein Testprojekt zusammen geknüppelt. Kompiliert zumindest einwandfrei. Auch zur Laufzeit kommen bei mir keinerlei Fehler.

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, DECHash;

type
  THashTest = class
  private

  public
    function HashData(HashClass: THashBaseMD4): string;
  end;


{ THashTest }

function THashTest.HashData(HashClass: THashBaseMD4): string;
begin
  Result := HashClass.CalcString('');
end;

var
  sha256: THash_SHA256;
  md5: THash_MD5;
  hashTest: THashTest;

begin
  try
    sha256 := THash_SHA256.Create;
    md5 := THash_MD5.Create;
    hashTest := THashTest.Create;
    Writeln(hashTest.HashData(sha256));
    Writeln(hashTest.HashData(md5));
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[DieDolly]

Habe das jetzt etwas umständlich gemacht aber es funktioniert. Mein Aufruf bleibt der gleiche.

Delphi-Quellcode:

unit DEC.Hashing;

interface

uses
 System.Classes, System.SysUtils, DECHash, DECFormat;

type
 THashMethod = (hmMD5, hmSHA256);

type
 THashFunctions = record
 private
  class function GetHash(const HashMethod: THashMethod): THashBaseMD4; static;
  class function HashStringBase(const Text: string; const HashMethod: THashMethod): string; static;
  class function HashFileBase(const FileName: string; const HashMethod: THashMethod): string; static;
  class function HashStreamBase(const Stream: TStream; const HashMethod: THashMethod): string; static;
 public
  class function MD5String(const Text: string): string; static;
  class function MD5File(const FileName: string): string; static;
  class function MD5Stream(const Stream: TStream): string; static;

  class function SHA256String(const Text: string): string; static;
  class function SHA256File(const FileName: string): string; static;
  class function SHA256Stream(const Stream: TStream): string; static;
 end;

implementation

// Base functions
// ==============================================================================================================================================
class function THashFunctions.GetHash(const HashMethod: THashMethod): THashBaseMD4;
begin
 Result := nil;
 case HashMethod of
  hmMD5:
   Result := THash_MD5.Create;
  hmSHA256:
   Result := THash_SHA256.Create;
 end;
end;

class function THashFunctions.HashStringBase(const Text: string; const HashMethod: THashMethod): string;
var
 Hash: THashBaseMD4;
begin
 Hash := THashFunctions.GetHash(HashMethod);
 try
  Result := string(Hash.CalcString(RawByteString(Text), TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashFileBase(const FileName: string; const HashMethod: THashMethod): string;
var
 Hash: THashBaseMD4;
begin
 Hash := THashFunctions.GetHash(HashMethod);
 try
  Result := string(Hash.CalcFile(FileName, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashStreamBase(const Stream: TStream; const HashMethod: THashMethod): string;
var
 Hash: THashBaseMD4;
begin
 Hash := THashFunctions.GetHash(HashMethod);
 try
  Result := string(Hash.CalcStream(Stream, Stream.Size, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;
// ==============================================================================================================================================

// MD5
// ==============================================================================================================================================
class function THashFunctions.MD5String(const Text: string): string;
begin
 Result := HashStringBase(Text, THashMethod.hmMD5);
end;

class function THashFunctions.MD5File(const FileName: string): string;
begin
 Result := HashFileBase(FileName, THashMethod.hmMD5);
end;

class function THashFunctions.MD5Stream(const Stream: TStream): string;
begin
 Result := HashStreamBase(Stream, THashMethod.hmMD5);
end;
// ==============================================================================================================================================

// SHA256
// ==============================================================================================================================================
class function THashFunctions.SHA256String(const Text: string): string;
begin
 Result := HashStringBase(Text, THashMethod.hmSHA256);
end;

class function THashFunctions.SHA256File(const FileName: string): string;
begin
 Result := HashFileBase(FileName, THashMethod.hmMD5);
end;

class function THashFunctions.SHA256Stream(const Stream: TStream): string;
begin
 Result := HashStreamBase(Stream, THashMethod.hmMD5);
end;
// ==============================================================================================================================================

end.

[Aviator]

Und warum? Ich habe doch geschrieben wie es funktioniert.

Naja mach wie du denkst. Du musst ja mit dem Source Code klar kommen.

[DieDolly]

Ich verstehe nicht wie ich dein Beispiel in eine Unit packen soll. Ich brauche am Ende eine Unit wo ich von Außen nur aufzurufen brauche ob ich md5 oder sha256 möchte jeweils für string, datei und stream. Ich kann deinen Code jetzt 6x kopieren aber dann habe ich wieder doppelten Code.

[TiGü]

Ich würde dir erstmal sowas vorschlagen:

Delphi-Quellcode:

unit DEC.Hashing;

interface

uses
 System.Classes, System.SysUtils, DECHash, DECFormat;

type
 THashBaseMD4Class = class of THashBaseMD4;

type
 THashFunctions = record
 private
  class function HashStringBase(const Text: string; const HashClass: THashBaseMD4Class): string; static;
  class function HashFileBase(const FileName: string; const HashClass: THashBaseMD4Class): string; static;
  class function HashStreamBase(const Stream: TStream; const HashClass: THashBaseMD4Class): string; static;
 public
  class function MD5String(const Text: string): string; static;
  class function MD5File(const FileName: string): string; static;
  class function MD5Stream(const Stream: TStream): string; static;

  class function SHA256String(const Text: string): string; static;
  class function SHA256File(const FileName: string): string; static;
  class function SHA256Stream(const Stream: TStream): string; static;
 end;

implementation

// Base functions
// ==============================================================================================================================================
class function THashFunctions.HashStringBase(const Text: string; const
    HashClass: THashBaseMD4Class): string;
var
 Hash: THashBaseMD4;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcString(RawByteString(Text), TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashFileBase(const FileName: string; const
    HashClass: THashBaseMD4Class): string;
var
 Hash: THashBaseMD4;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcFile(FileName, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashStreamBase(const Stream: TStream; const
    HashClass: THashBaseMD4Class): string;
var
 Hash: THashBaseMD4;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcStream(Stream, Stream.Size, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;
// ==============================================================================================================================================

// MD5
// ==============================================================================================================================================
class function THashFunctions.MD5String(const Text: string): string;
begin
 Result := HashStringBase(Text, THash_MD5);
end;

class function THashFunctions.MD5File(const FileName: string): string;
begin
 Result := HashFileBase(FileName, THash_MD5);
end;

class function THashFunctions.MD5Stream(const Stream: TStream): string;
begin
 Result := HashStreamBase(Stream, THash_MD5);
end;
// ==============================================================================================================================================

// SHA256
// ==============================================================================================================================================
class function THashFunctions.SHA256String(const Text: string): string;
begin
 Result := HashStringBase(Text, THash_SHA256);
end;

class function THashFunctions.SHA256File(const FileName: string): string;
begin
 Result := HashFileBase(FileName, THash_SHA256);
end;

class function THashFunctions.SHA256Stream(const Stream: TStream): string;
begin
 Result := HashStreamBase(Stream, THash_SHA256);
end;
// ==============================================================================================================================================

end.

Aber das finde ich unelegant.
Denn es geht noch besser.

Delphi-Quellcode:

unit DEC.Hashing;

interface

uses
 System.Classes, System.SysUtils, DECHash, DECFormat,
 DECHashAuthentication; // <----- neue Unit, nicht vergessen, da kommt die Definition von TDECHashAuthentication her

type
 THashFunctions = record
 public
  class function HashString<HashClass: TDECHashAuthentication, constructor>(const Text: string): string; static;
  class function HashFile<HashClass: TDECHashAuthentication, constructor>(const FileName: string): string; static;
  class function HashStream<HashClass: TDECHashAuthentication, constructor>(const Stream: TStream): string; static;
 end;

implementation

// Base functions
// ==============================================================================================================================================
class function THashFunctions.HashString<HashClass>(const Text: string): string;
var
 Hash: TDECHashAuthentication;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcString(RawByteString(Text), TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashFile<HashClass>(const FileName: string): string;
var
 Hash: TDECHashAuthentication;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcFile(FileName, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

class function THashFunctions.HashStream<HashClass>(const Stream: TStream): string;
var
 Hash: TDECHashAuthentication;
begin
 Hash := HashClass.Create;
 try
  Result := string(Hash.CalcStream(Stream, Stream.Size, TFormat_HEX)).ToLower;
 finally
  Hash.Free;
 end;
end;

end.

Anzuwenden dann so:

Delphi-Quellcode:

var
  LStream: TStream;
  MyHash: string;
begin
  MyHash := THashFunctions.HashString<THash_MD5>('Hello');
  MyHash := THashFunctions.HashFile<THash_MD5>('World');
  LStream := TFileStream.Create('C:\temp\Project2.dpr', fmCreate);
  try
    MyHash := THashFunctions.HashStream<THash_MD5>(LStream);
  finally
    LStream.Free;
  end;

  MyHash := THashFunctions.HashString<THash_SHA256>('Hello');
  MyHash := THashFunctions.HashFile<THash_SHA256>('World');
  LStream := TFileStream.Create('C:\temp\Project2.dpr', fmCreate);
  try
    MyHash := THashFunctions.HashStream<THash_SHA256>(LStream);
  finally
    LStream.Free;
  end;
end.

Vorteil: Alle anderen Nachfahren von TDECHashAuthentication können können jetzt ganz einfach benutzt werden (THash_RipeMD128, THash_Tiger, THash_SHA512, THash_Sapphire...usw.)

[TurboMagic]

Danke an alle, die hier auch zur DEC Support leisten...
Top! Gerne weiter so...

[TiGü]

@DieDolly: Bist du hier zu einer für dich brauchbaren Lösung gekommen?

[DieDolly]

Danke der Nachfrage, ja das bin ich. Ich verwende deinen Vorschlag.