Hilfe bei Umstellung Unit DEC5.1 zu DEC6.0

[TurboMagic]

Hallo,

nun ja, ich kann nicht dauernd DP lesen, so sehr ich evtl. auch möchte.
Es gibt da halt noch sowas, das nennt sich Arbeitgeber...

=> ich hab' das mal soweit abends umgesetzt gehabt, dass es Compiliert.
Dass es jetzt zur Laufzeit crasht is blöd, muss aber nacher weiter untersucht werden.
Aber eines nach dem Anderen...

Grüße
TurboMagic

[TurboMagic]

Hallo,

möglicherweise hab' ich es gelöst:

Statt des Typcasts PassBytes := TDECHashAuthentication(...
muss es PassBytes := THash_SHA256(... sein.

Man merkt es schon am letzten Assert in der KDFx drin,
da DigestSize nur in einer konkreten Klasse vernünftig
funktionieren kann.

=> mal mit deinen Testdaten testen.

Grüße
TurboMagic

[EdAdvokat]

...ja es funktioniert nun. Das wird es wohl gewesen sein.

@haentschman sollte sich das nun mal ansehen und sein ok dazu geben mit den eigenen Werten.

[EdAdvokat]

auch ein Test mit den SQL-Werten von @haentschman klappt es. Enc und Dec so wie in den SQL-Dateien vermerkt funktioniert nun. Mal schauen was er dazu meint.

[haentschman]

Moin...

...ihr habt mir das Testen schon fast abgenommen. Ich werde erst am Wochenende dazu kommen, es live mit dem Projekt zu testen.

Danke an Euch...

Zitat:

nun ja, ich kann nicht dauernd DP lesen, so sehr ich evtl. auch möchte.

Trotzdem perfekt. Selbst wenn es einen Monat gedauert hätte...

[haentschman]

Moin...

...hat etwas länger gedauert.

1. PassBytes := THash_SHA256( getauscht
2. schöne Zugriffsverletzung wie vorher ...wie jetzt?
3. Erinnerung an "...nur in einer konkreten Klasse vernünftig funktionieren kann."
4. Klasse erzeugt (Bild)
5. und siehe da...es funktioniert. (Bild)

...und keine Leaks.

PS: Warnung beseitigt: TextFormat: TDECFormatClass = TFormat_Base64; statt TextFormat: TDECFormatClass = TFormat_MIME64;


Danke nochmal...

[EdAdvokat]

Ich frage mal ganz naiv: muß wirklich HashClass:=TDECHashClass(THash_SHA256.create); und deren Freigabe eingefügt werden.

ich habe in der class function ToolCrypt.Encode und ...Decode lediglich
PassBytes := THash_SHA256.KDFx(aKey[1],...geändert, ohne
HashClass:=TDECHashClass(THash.SHA256.create); und deren Freigabe aufzurufen.
Das hat ohne Fehler und Warnungen compiliert.

Muß ich wirklich das create aufrufen?
TDECFormatClass rufe ich ja auch nicht mit create auf

Ich habe beide Varianten ausprobiert und das gleiche Ergebnis: keine Fehler, keine Warnungen

[haentschman]

Hi...

im Original ist:

Delphi-Quellcode:

PassBytes := TDECHashAuthentication(ValidHash(HashClass)).KDFx(aKey[1],
...

...da fehlt was bei dir

Delphi-Quellcode:

THash_SHA256.KDFx(aKey[1]
...

-> ValidHash(HashClass)
...mit

Delphi-Quellcode:

PassBytes := THash_SHA256(ValidHash(HashClass)).KDFx(aKey[1],
...

...ergibt es eine Zugriffsverletzung.

THash_SHA256.KDFx(aKey[1] ...probiere ich mal aus. (geht)

PS: Wofür ist diese Prüfung da? (ValidHash)

[EdAdvokat]

Damit wir nicht nur über Code-Schnipsel sprechen hier die gesamte unit, die nun funktioniert,
wahlweise ergänzt mit HashClass:= TDECHashClass(THash.SHA256.create); :

Delphi-Quellcode:

unit Tools.Crypt;

interface

uses
  System.SysUtils,
  DECUtil, DECHash,
  DECHashBase, DECCipherBase, DECCiphers, DECFormatBase, DECFormat,
  DECHashAuthentication, DECRandom;

const
  conKey = 'aYr14iaz8u)xO7Ok';

var
  CipherMode: TCipherMode = cmCBCx;
  HashClass: TDECHashClass = THash_SHA256;
  TextFormat: TDECFormatClass = TFormat_Base64;
  KDFIndex: LongWord = 1;

type
  TToolsCrypt = class
  public
    class function Decrypt(aHash: string; aKey: string = ''): string;
    class function Encrypt(aText: string; aKey: string = ''): string;
  end;

implementation

{ TToolsCrypt }

class function TToolsCrypt.Decrypt(aHash, aKey: string): string;
var
  Cipher: TCipher_Rijndael;
  Salt: RawByteString; //Binary;
  Data: RawByteString;
  Check: RawByteString;
  Pass: RawByteString;
  PassBytes: TBytes;
  Len: Integer;
begin
  if aKey = '' then
  begin
    aKey := conKey;
  end;

  Cipher := TCipher_Rijndael.Create;
  try
    Salt := ValidFormat(TextFormat).Decode(RawByteString(aHash));
    Len := Length(Salt) - 16 - Cipher.Context.BufferSize;
    Data := Copy(Salt, 17, Len);
    Check := Copy(Salt, Len + 17, Cipher.Context.BufferSize);
    SetLength(Salt, 16);
    PassBytes := THash_SHA256.KDFx(aKey[1],
                                  Length(aKey) * 2,
                                  Salt[1],
                                  Length(Salt),
                                  Cipher.Context.KeySize,
                                  KDFIndex);

    SetLength(Pass, Length(PassBytes));
    Move(PassBytes[0], Pass[low(Pass)], Length(PassBytes));

    Cipher.Mode := CipherMode;
    Cipher.Init(Pass);
    SetLength(Result, Len div 2);
    Cipher.Decode(Data[1], Result[1], Len);
    if Check <> Cipher.CalcMAC then
    begin
      Result := '';
    end;
  finally
    Cipher.Free;
    //ProtectBinary(Salt);
    ProtectString(Salt);
    ProtectString(Data);
    ProtectString(Check);
    ProtectString(Pass);
  end;
end;

class function TToolsCrypt.Encrypt(aText, aKey: string): string;
var
  Cipher: TCipher_Rijndael;
  SaltBytes : TBytes;
  Salt: RawByteString; //Binary;
  Data: RawByteString; //Binary;
  Pass: RawByteString; //Binary;
  PassBytes: TBytes;
begin
  if aKey = '' then
  begin
    aKey := conKey;
  end;

  Cipher := TCipher_Rijndael.Create;
  try
    SaltBytes := RandomBytes(16); //RandomBinary(16);
    SetLength(Salt, Length(SaltBytes));
    Move(SaltBytes[0], Salt[low(Salt)], Length(SaltBytes));

    PassBytes := THash_SHA256.KDFx(aKey[1],
                                  Length(aKey) * 2,
                                  Salt[1],
                                  Length(Salt),
                                  Cipher.Context.KeySize,
                                  KDFIndex);

    SetLength(Pass, Length(PassBytes));
    Move(PassBytes[0], Pass[low(Pass)], Length(PassBytes));

    Cipher.Mode := CipherMode;
    Cipher.Init(Pass);
    SetLength(Data, Length(aText) * 2);
    Cipher.Encode(aText[1], Data[1], Length(Data));
    Result := string(ValidFormat(TextFormat).Encode(Salt + Data + Cipher.CalcMAC));
  finally
    Cipher.Free;
    ProtectString(Salt);
    ProtectString(Data);
    ProtectString(Pass);
  end;
end;

end.

Hier wird

Delphi-Quellcode:

PassBytes:= THash_SHA256.KDFx(aKey[1],
                                  Length(aKey) * 2,
                                  Salt[1],
                                  Length(Salt),
                                  Cipher.Context.KeySize,
                                  KDFIndex);

anders als zuvor aufgerufen.
Diese unit funktioniert bei mir mit oder ohne den gesonderten Aufruf von HashClass:=.....
ohne Fehler und Warnungen
Schau noch mal in #12 nach

[haentschman]

Zitat:

Diese unit funktioniert bei mir mit oder ohne den gesonderten Aufruf von HashClass:=.....
ohne Fehler und Warnungen

D10.2 <> D12 ... macht vieleicht was aus.