DEC SHA Verständnissverwirrung...

[TurboMagic]

Hallo,

ich arbeite ja immer noch an einer neuen Version dieser Cryptobibliothek:
https://github.com/winkelsdorf/Delph...tionCompendium

Dazu versuche ich alle bekannten Probleme gelöst zu bekommen um dann eine neue Version zu veröffentlichen und nach
dieser langsam mit der Umsetzung neuerer Algorithmen zu beginnen. Soweit jedenfalls der Plan.

Nun habe ich herausgefunden, dass die Klasse THash_SHA eigentlich der schon seit 1995 als unsicher geltende SHA0 ist.
Es gibt auch eine Klasse THash_SHA1, die dem SHA1 entspricht. (ja der ist inzwischen auch als unsicher bekannt)
Der Plan war die Klasse THash_SHA in THash_SHA0 umzubenennen. Könnte ich einfach tun, dann wäre der Post hier
überflüssig, aber:

Ich habe herausgefunden, dass THash_SHA und THash_SHA1 für die jeweilige EIngabe der Testdaten "abc" den jeweiligen
gültigen Hash-Wert ausrechnen. So soll es ja auch sein. Aber:

THash_SHA1 ist wie folgt deklariert:

THash_SHA1 = class(THash_SHA); siehe dazu DECHash.pas aus obigem Repository.

Meine Frage nun: wie kann es sein, dass THash_SHA1 auf die Eingabe der selben Testdaten "abc" einen ganz
anderen Hash als THash_SHA zurückliefert, obwohl der eigentlich ausgeführte Code (zumindest konnte ich beim Debuggen
auf die Schnelle keinen Unterschied feststellen - es werden die selben Methoden aufgerufen!) der selbe ist?

Hier noch ein kurzes Testprogramm für Leute die dieses Rätsel nachvollziehen möchten:

Delphi-Quellcode:

program SHA;

{$APPTYPE CONSOLE}

{$I ..\Source\DECOptions.inc}

{$R *.res}

uses
  System.SysUtils,
  DECBaseClass in '..\Source\DECBaseClass.pas',
  DECFormat in '..\Source\DECFormat.pas',
  DECFormatBase in '..\Source\DECFormatBase.pas',
  DECHash in '..\Source\DECHash.pas',
  DECHashBase in '..\Source\DECHashBase.pas',
  DECHashInterface in '..\Source\DECHashInterface.pas',
  DECTypes in '..\Source\DECTypes.pas',
  DECUtil in '..\Source\DECUtil.pas',
  DECUtilRawByteStringHelper in '..\Source\DECUtilRawByteStringHelper.pas',
  DECCRC in '..\Source\DECCRC.pas',
  DECData in '..\Source\DECData.pas';

var
  Hash_SHA  : THash_SHA;
  Hash_SHA1 : THash_SHA1;
  Data: TBytes;
  Result : TBytes;

function BytesToHexString(b: TBytes):string;
begin
  for var i : Integer := 0 to High(b) do
    result := result + IntToHex(b[i], 2);
end;

begin
  SetLength(Data, 3);
  Data[0] := ord('a');
  Data[1] := ord('b');
  Data[2] := ord('c');

  // Original NIST SHA0 test data: 0164B8A9 14CD2A5E 74C4F7FF 082C4D97 F1EDF880
  // Correct SHA1 test data: A9993E364706816ABA3E25717850C26C9CD0D89D

  try
    try
      Hash_SHA := THash_SHA.Create;
      Hash_SHA.Init;

      Result := Hash_SHA.CalcBytes(data);
      WriteLn(BytesToHexString(Result));
    finally
      Hash_SHA.Free;
    end;

    try
      Hash_SHA1 := THash_SHA1.Create;
      Hash_SHA1.Init;

      Result := Hash_SHA1.CalcBytes(data);
      WriteLn(BytesToHexString(Result));
    finally
      Hash_SHA1.Free;
    end;

    ReadLn;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Also mich verwirrt das jetzt total...

Grüße

TurboMagic

[Klaus01]

Guten Abend,

Delphi-Quellcode:

procedure THash_SHA.DoTransform(Buffer: PUInt32Array);
var
  A, B, C, D, E, T: UInt32;
  W: array[0..79] of UInt32;
  I: Integer;
begin
  SwapUInt32Buffer(Buffer[0], W, 16);
  if ClassType = THash_SHA then
  begin
    for I := 16 to 79 do
    begin
      T := W[I - 3] xor W[I - 8] xor W[I - 14] xor W[I - 16];
      W[I] := T;
    end;
  end
  else
  begin
    for I := 16 to 79 do
    begin
      T := W[I - 3] xor W[I - 8] xor W[I - 14] xor W[I - 16];
      W[I] := T shl 1 or T shr 31;
    end;
  end;

wird hier nicht bei einer Klasse ungleich THash_SHA der else Zweig abgearbeitet.
Also auch bei THash_SHA1.

Grüße
Klaus

[TurboMagic]

Vielen Dank für dieses "Forschungsergebnis". jetzt ist's mir auch klar und damit kann ich die Sache denke ich noch ein wenig weiter verbessern...

[Sherlock]

Nichts für ungut, aber...das könnte abenteuerlich werden, wenn Du sowas übersiehst.

Sherlock

[TurboMagic]

Naja. Schon gesehen: in dem Projekt gibt's viele Unit Tests, u.a. auch für die grundlegende Funktionalität dieser Hash-Klassen.
Es gibt inzwischen auch Unit Tests die Dinge abprüfen, welches das in älteren Versionen der Bibliothek zum Testen benutzte
kryptische Testprogramm nicht getestet hat.

Eine Fallunterscheidung im Code basierend auf dem Klassennamen ist auch ein eher selten genutztes Konstrukt.