Funktion von altem DEC in neues DEC 6.3

[Hobbycoder]

Hi,

Ich brauche mal eure Hilfe. Hier gibt es doch bestimmt ein paar DEC-Spezialisten.
Ich haben einen alten Code, den ich vor Jahren mal irgendwo herbekommen habe. Für die damalige DEC-Version.

Nun gibt es ja die DEC 6.3 für D12, wo dieser nicht mehr läuft. Mein Wissen bezüglich DEC beschränkt sich leider aus das absolute Minimum, so dass ich selbst nicht in der Lage bin ihn auf 6.3 anzupassen.
Mit den beiden Funktionen Encrypt und Decrypt habe ich für eine INI-Datei Passwörter verschlüsselt.
In dem Parameter AText wird jeweils das zu verschlüsselnde Passwort angegeben, und im APassword ein Key, mit dem Verschlüsselt wurde.
Nun könnte ich natürlich die Funktionen komplett austauschen, dann würden jedoch die bereits gespeicherten Daten nicht mehr korrekt gelesen werden können.
Also wäre es toll, wenn man das mit DEC 6.3 hinbekäme, dass die Funktionen so weiterlaufen können.

(Ist auch als Datei angehängt)

Delphi-Quellcode:

unit u_scsettings;

interface

uses System.Classes, System.IniFiles, System.SysUtils, System.Generics.Collections,
   DECUtil, DECCipher, DECHash, DECFmt, Vcl.Dialogs, u_tools;

var
  ACipherClass: TDECCipherClass = TCipher_Rijndael;
  ACipherMode: TCipherMode = cmCBCx;
  AHashClass: TDECHashClass = THash_Whirlpool;
  ATextFormat: TDECFormatClass = TFormat_MIME64;
  AKDFIndex: LongWord = 1;

implementation

function Encrypt(const AText: string; const APassword: string): string;
var
  ASalt: Binary;
  AData: Binary;
  APass: Binary;
begin
  with ValidCipher(ACipherClass).Create, Context do
  try
    ASalt := RandomBinary(16);
    APass := ValidHash(AHashClass).KDFx(APassword[1], Length(APassword) * SizeOf(APassword[1]), ASalt[1], Length(ASalt), KeySize, TFormat_Copy, AKDFIndex);
    Mode := ACipherMode;
    Init(APass);
    SetLength(AData, Length(AText) * SizeOf(AText[1]));
    Encode(AText[1], AData[1], Length(AData));
    Result := ValidFormat(ATextFormat).Encode(ASalt + AData + CalcMAC);
  finally
    Free;
    ProtectBinary(ASalt);
    ProtectBinary(AData);
    ProtectBinary(APass);
  end;
end;

function Decrypt(const AText: String; const APassword: String; var Failed: Boolean): String; 
var
  ASalt: Binary;
  AData: Binary;
  ACheck: Binary;
  APass: Binary;
  ALen: Integer;
begin
  with ValidCipher(ACipherClass).Create, Context do
  try
    ASalt := ValidFormat(ATextFormat).Decode(AText);
    ALen := Length(ASalt) - 16 - BufferSize;
    AData := System.Copy(ASalt, 17, ALen);
    ACheck := System.Copy(ASalt, ALen + 17, BufferSize);
    SetLength(ASalt, 16);
    APass := ValidHash(AHashClass).KDFx(APassword[1], Length(APassword) * SizeOf(APassword[1]), ASalt[1], Length(ASalt), KeySize, TFormat_Copy, AKDFIndex);
    Mode := ACipherMode;
    Init(APass);
    SetLength(Result, ALen div SizeOf(AText[1]));
    Decode(AData[1], Result[1], ALen);
    Failed:= ACheck <> CalcMAC;
  finally
    Free;
    ProtectBinary(ASalt);
    ProtectBinary(AData);
    ProtectBinary(ACheck);
    ProtectBinary(APass);
  end;
end;

end.

Dank an alle.

[jaenicke]

Hättest du vielleicht ein Beispielprojekt mit den erwarteten Ergebnissen? Sprich das Beispielwerte aus der bisherigen Version drin hat und prüft? Ich hätte schon Ideen, was geändert werden muss, aber ohne zu wissen, womit du das genau erstellt hast, ist das schwer zu prüfen.

Wenn ich ein Projekt hätte, das prüft, ob die erwarteten Ergebnisse beim Aufruf der Funktionen herauskommen, könnte ich das mal ausprobieren.

[Hobbycoder]

Ich hab dir mal ein Beispiel angehängt.

In der Datei Verschlusselungsbeispieldaten.txt sind sowohl Klartext- als auch Verschlüsselt-String drin.
Die Zip-Datei ist mit Passwort gesichert, weil ich in den Units den original Verschlüsselungskey drin habe. Das Passwort für die Zip hast du per PN.

[EdAdvokat]

Hallo,
anbei die unit tools.crypt, die auch mit DEC 6.3 laufen sollte. Ich habe sie in einem kleinen
Projekt "KeyGenerator" mit DEC 6.41 verarbeitet, um eine Memo-Liste zu verschlüsseln und dann
wahlweise auch wieder zu entschlüsseln.
Dazu greife ich auf ein edit-Feld mit dem Key zu, der natürlich nur als ##### zu erkennen ist.
Natürlich könnten div. units aus diesem Tool herausgenommen werden, da du diese nicht benötigst.
Ist es das was du suchts?

Delphi-Quellcode:

unit Tools.Crypt;

interface

uses
  System.SysUtils,
  DECUtil, DECHash,
  //DECCipher, DECFmt;
  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;

  HashClass:=TDECHashClass(THash_SHA256.create);

 try
  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;

 finally
   THash_SHA256(HashClass).Free;
 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;

  HashClass:=TDECHashClass(THash_SHA256.create);
 try

  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;
 finally
   THash_SHA256(HashClass).Free;
 end;
end;

end.

[jaenicke]

Ich wollte das gerade testen, als ich die Antwort gesehen habe, deshalb konnte ich das gerade testen. Da kommt zwar etwas anderes bei der Verschlüsselung heraus, aber die Entschlüsselung klappt offenbar. Von daher halte ich mich mal zurück.

[haentschman]

conKey = 'aYr14iaz8u)xO7Ok'; ...kommt mir bekannt vor.