DEC 6.0 Salzstreuer

[Klapauzius]

Anlässlich des verfrühten Weihnachtsgeschenkes von TurboMagic (Danke!) hab ich mir mal das DEC angeschaut. Vieles was da in DEC angeboten wird, kann ich verstehen und nachvollziehen, auch mit Hilfe der beiligenden Beispiele.

Mein Problem:

Eine sichere Blockverschlüsselung beinhaltet für mich

1. Passwordhash
2. Salz
3. Verschlüsseln

Meine Versuche das zu realisieren scheitern aber grandios, hauptsächlich wohl daran, dass mir das grundlegende Verständnis für Verschlüsslung fehlt.

Mein Versuch um Salz einzustreuen

Delphi-Quellcode:

//FPassord: utf8String;

function MyClass.GenerateHashedPw: TBytes;
var
  Hash: THash_SHA256;
  Salt: Cardinal;
  SaltBytes: TBytes;
  PW: TBytes;
  HashedPw: TBytes;
begin
  Salt:=  Random(16);
  Hash:= THash_SHA256.create;
  try
   // Transform inputs to Bytes
   SaltBytes:= TEncoding.utf8.GetBytes(inttostr(Salt));
   PW:=  TEncoding.utf8.GetBytes(FPassword);

   //Generate Hashed PW
   HashedPw:= Hash.KDF1(PW, SaltBytes, Cipher.Context.KeySize);
   result:= HashedPw;

  finally
    Hash.Free;
  end;

anschliessend verschlüssle ich Text

Delphi-Quellcode:

//cipher: Cipher:= TCipher_AES
//FIV, FFIler: TBytes

 Cipher.Init(GenerateHashedPw, FIV, FFiller);
 result:= Cipher.EncodeStringToString(PlainText, TFormat_BASE64));

Beim Entschlüsseln des Strings erhalte ich aber ein falsches Resultat. Lasse ich das Salz weg, funktioniert alles.

Frage oder Bitte:
Gibt es irgendwo ein vollständiges Beispiel für Verschlüsselung mit Salz oder kann mir jemand erklären wie ich das Salz korrekt verwende?

[Rollo62]

Salt:= Random(16); Kann es sein das Du beim Verschlüsseln und Entschlüsseln verschiedenes "Salze" benutzt ?
Versuche mal statt "Random", einfach einen festen Wert zu nehmen.
Ausserdem würde ich für Salt nicht nur ein Integer nehmen, sondern eine längere Zeichenfolge.

[Andreas13]

Vielleicht mußt Du vor dem Aufruf von Salt:= Random(16); den Zufallszahlengenerator durch Randomize zurücksetzen, um das geleiche "Salz" zu erhalten.
Gruß, Andreas

[Klapauzius]

@Rollo62 Aufgrund meiner mangelnden Verschlüsselungskenntnissen habe ich also Salt falsch interpretiert. Bis anhin habe ich Lockbox verwendet, wo keine Hintergrundinformationen über Verschlüsselung notwendig sind. Jetzt hat mich einfach stutzig gemacht, dass ich bei Lockbox nie das gleiche Resultat für die Verschlüsselung eines Strings (bei gleichem Passwort) erhalte, bei DEC bleibt das Resultat aber immer gleich. Deshalb dachte ich, dass das Salz verantwortliche wäre für diese unterschiedlichen Resultate bei Lockbox.

Zum Salt random(16): Dies wurde in meinem Code nur als einfache Möglichkeit verwendet um Salt zu testen.

Da ich Salt falsch verstanden habe, meine Frage:
wie erzeuge ich dann unterschiedliche Resultate bei der Verschlüssung, wenn gleicher Text und gleiches Passwort verwendet wird (analog zu Lockbox)?

[samso]

@Andreas13:
Randomize setzt den Zufallsgenerator nicht zurück, sondern setzt einen neuen -mehr oder weniger- zufälligen Startwert. Nach Ausführen von Randomize ist der erste Wert Random(16) also nicht fixed.

[Rollo62]

Das Salt ist meiner Meinung nach nichts Geheimnisvolles.
Vielleicht sehe ich das zu einfach, aber für mich ist das Salz praktisch nur die Verlängerung des eigentlichen Passwortes um noch ein paar kryptische Daten.
https://code-bude.net/2015/03/30/gru...ing-mit-salts/

Es geht dabei darum dass das Hacken von Passwörten wie "Sabine, MeinPasswort, SehrSicher, Geheim, ..." zu erschweren/verhindern.
Dadurch dass dem simplen User-Passwort noch etwas Salz hinzugefügt wird, wird erreicht
das diese einfachen Wörter dann nicht mehr aus Lookup-Tabellen mittels BruteForce gesucht werden können.

[Klapauzius]

Danke, dann habe ich Salt jetzt verstanden.

Hier meine Testklasse zur Textverschlüsselung:
Sieht das so sicherheitstechnisch korrekt aus?

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.SysUtils, System.TypInfo, Generics.Collections, FMX.Platform,
  DECCipherBase, DECFormatBase, DECBaseClass, DECFormat, DECCipherModes,
  DECCipherFormats, DECCiphers, DECUtil, DECHashBase, DECHash, DECRandom,
  System.Classes, FMX.Dialogs;

type
  DECEnc = class(TObject)
  private
    Cipher: TCipher_AES;
    FFiller: Byte;
    FIV: TBytes;
    FPassword: UTF8String;
    function GenerateHashedPw: TBytes;
    procedure SetPassword(const Value: UTF8String);

  public
    constructor Create;
    property Password: UTF8String read FPassword write SetPassword;
    destructor Destroy; override;
    function DecryptString(ENC_Base64String: UTF8String): UTF8String;
    function EncryptString(const PlainText: UTF8String): UTF8String;

  end;

implementation
 
constructor DECEnc.Create;
begin
  inherited;
    FIV:= TEncoding.UTF8.GetBytes('2A7Q5!8;');
    RandomBuffer(FFiller,4);
    Cipher:= TCipher_AES.Create;
    Cipher.Mode := cmCBCx;

end;

destructor DECEnc.Destroy;
begin
  cipher.Free;
  inherited;

end;

function DECEnc.DecryptString(ENC_Base64String: UTF8String): UTF8String;
var
 output: TBytes;
 DecodedString: UTF8String;
 input: TBytes;
begin
    Cipher.Init(GenerateHashedPw,FIV,FFiller);
    Input  := System.SysUtils.BytesOf(ENC_Base64String);
    output := Cipher.DecodeBytes(TFormat_Base64.decode(Input));
    result:= TEncoding.UTF8.GetString(output);
end;

function DECEnc.EncryptString(const PlainText: UTF8String): UTF8String;
var
  output: utf8String;
  Data:TBytes;
begin
    Cipher.Init(GenerateHashedPw,FIV,FFiller);
    output:= UTF8Encode(Cipher.EncodeStringToString(PlainText, TFormat_BASE64));
    result:= output;
end;

function DECEnc.GenerateHashedPw: TBytes;
var
  Hash: THash_SHA256;
  Salt: utf8string;
  SaltBytes: TBytes;
  PW: TBytes;
  HashedPw: TBytes;
begin
  Salt:=  'wer 9845747 198498 34534';
  Hash:= THash_SHA256.create;
  try
   SaltBytes:= TEncoding.utf8.GetBytes(Salt);
   PW:=  TEncoding.utf8.GetBytes(FPassword);
   HashedPw:= Hash.KDF1(PW,SaltBytes,Cipher.Context.KeySize);
   result:= HashedPw;
  finally
     Hash.Free;
  end;

end;

procedure DECEnc.SetPassword(const Value: UTF8String);
begin
  FPassword := Value;
end;

end.

[EdAdvokat]

Salt in AES wird meines Wissens nach durch die PBKDF2-Funktion realisiert.
Das Salt bezieht sich darauf, ein Passwort in einen geheimen Schlüssel zu verwandeln.
PBKDF2 ist also eine passwortbasierte Schlüsselableitungsfunktion.
Ich habe dazu mal gelesen, dass ein zufälliges Salt mit 1000 SHA-256-Iterationen zu der entsprechenden
Schlüsselableitung führen. Es ist also bereits integraler Bestandteil von AES.

Wenn es jedoch um den vor der Verwendung des symetrischen AES-Verfahrens notwendigen Schlüsseltausch
geht, werden zumeist asymetrische Chiffrierverfahren verwendet. Ein klassisches Beispiel
ist das Diffie-Hellman-Merkle Verfahren oder RSA natürlich mit der entsprechenden Schlüsselstärke,
da es sich ja um den Austausch der Passwörter für das Chiffrierverfahren AES beispielsweise
handelt.
Hier sollte also das Password und das Salt in entsprechender Länge mit einem krypt. Hash versehen
werden.
Dazu hat Rollo62 einen sehr interessanten Link gepostet, der die ganze Angelegenheit ausführlich
beschreibt.

[Andreas13]

Zitat von samso:

@Andreas13:
Randomize setzt den Zufallsgenerator nicht zurück, sondern setzt einen neuen -mehr oder weniger- zufälligen Startwert. Nach Ausführen von Randomize ist der erste Wert Random(16) also nicht fixed.

Sorry, Du hast recht Samso!

[Klapauzius]

Das Prinzip von Salt habe ich nun verstanden.

Bleibt noch meine Frage:
wie erzeuge ich dann unterschiedliche Resultate bei der Stringverschlüsselung, wenn gleicher Text und gleiches Passwort verwendet wird (analog zu Lockbox)?