DEC 6.0 Salzstreuer

[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.