Dateien verschlüssen mit Wolgang Ehrhardts Crypt-Units

[himitsu]

Ist es wirklich so schwer zu verstehen?

Entweder du reichts es einfach durch und kannst hier von außen z.B. deine Form/Self reingeben, oder sonsteine Instanz, wo dieses Interface enthalten ist.

Delphi-Quellcode:

type
  TDECCryptUtils = record
  private
    //
  public
    class function AESFileEncrypt(const FileName, Password: string; const Progress: IDECProgress = nil): string; static;
    class function AESFileDecrypt(const FileName, Password: string; const Progress: IDECProgress = nil): string; static;
  end;

class function TDECCryptUtils.AESFileDecrypt(const FileName, Password: string; const Progress: IDECProgress): string;
...
   Cipher.DecodeFile(FileName, FileName + '.decrypted.txt', Process);



type
  TForm1 = class(TForm, IDECProgress)
  ...

procedure TForm1.Button1Click(Sender: TObject);
begin
  TDECCryptUtils.AESFileDecrypt('Dat.ei', 'Pass', Self);
end;

Und im Notfalls kann man es auch immer kapseln, sich also Wrapper bauen, um zwischen den verschiedenen Möglichkeiten der Callbacks zu wechseln.

Delphi-Quellcode:

type
type
  TDECProgress = procedure(const Min, Max, Pos: Int64) of object;  // oder ohne "of object" oder mit "reference to" und mit oder ohne "stdcall"

  TDECProgressWrapper = class(TInterfacedObject, IDECProgress);
  private
    FOnProcess: TDECProgress;
    procedure Process(const Min, Max, Pos: Int64); stdcall;
  public
    constructor Create(const OnProcess: TDECProgress);
  end;

  TDECCryptUtils = record
  private
    //
  public
    class function AESFileEncrypt(const FileName, Password: string; const OnProgress: TDECProgress = nil): string; static;
    class function AESFileDecrypt(const FileName, Password: string; const OnProgress: TDECProgress = nil): string; static;
  end;

procedure TDECProgress.Process(const Min, Max, Pos: Int64); stdcall;
begin
  FOnProcess(Min, Max, Pos);
end;

constructor TDECProgress.Create(const OnProcess: TDECProgress);
begin
  inherited;
  Assert(Assigned(AProcess));
  FOnProcess := OnProcess;
end;

class function TDECCryptUtils.AESFileDecrypt(const FileName, Password: string; const OnProgress: TDECProgress): string;
...
   Cipher.DecodeFile(FileName, FileName + '.decrypted.txt', TDECProgressWrapper.Create(OnProgress));  // nur wenn Assigned(OnProgress) ... oder oben das Assert entfernen (und if-Assigned in den Callback)



type
  TForm1 = class(TForm)  // ohne IDECProgress
  ...

procedure TForm1.Button1Click(Sender: TObject);
begin
  TDECCryptUtils.AESFileDecrypt('Dat.ei', 'Pass', YourProcessMethod);
end;

Zitat:

Delphi-Quellcode:

  except
   //
  end;

Für sowas gehört man mindestens gevierteilt.

[DieDolly]

Geht das nicht einfacher?
Ich möchte keine extra Prozedur in einer Unit ablegen, die mit einer Form zusammenhängt. Kann ich die Progress-Prozedur nicht in dieselbe Unit legen wie auch den restlichen Code?
Genau deshalb ist mir ein CallBack lieber. Das hätte ich schon vor Stunden umsetzen können und dafür brauche ich keine extra Unit für.

Danke für deinen Code, weiter bringt der mich aber nicht. Da steht nicht die Prozedur bei wo ich Min Max und Pos abfrage.

Aber DEC hat sich für mich jetzt eh erledigt. Viel zu umständlich mit den ganzen Interfaces. Wenn ich das nicht einmal wie ein normales CallBack in derselben Unit deklarieren kann... dann interessiert mich das nicht. Sehr schade. Ich hatte gehofft, dass DEC endlich was Vernünftiges geworden wäre. Aber wenn auch jetzt hier der Interface-Wahn Einzug erhalten hat, dann nein danke.

[EdAdvokat]

ich will ja nicht aufdringlich wirken, aber schau Dir doch mal das beiliegende Programm an.
Es ist sehr kompakt und einfach gestaltet.
Es enthält auch eine Prograssfunktion, vermutlich jedoch nicht das was Du suchst - oder?

[DieDolly]

Für welche Version von LockBox ist das weil ich habe LockBox 3 schon installiert, kann es aber nicht kompilieren. Denke das ist für LockBox (2) ?
Kann Version 3 auch eh nicht installieren. Es installiert bei mir nur eine BPL-Datei, und keine Komponenten.

[EdAdvokat]

es ist wohl die Version 2.2 der Lockbox, mit der ich gearbeitet habe.

[TurboMagic]

So, im aktuellen Entwicklungszweig der DEC ist jetzt eine Variante mit referenz auf eine anonyme methode enthalten
(zumindest für die Ciphers, für die Hashes muss es noch umgesetzt werden). Dadurch kann für die Fortschrittsanzeige
nun eine Methode, eine normale prozedur oder eine annonyme "in-place" methode benutzt werden.

Das VCL basierte Demo Programm wurde auch aktualisiert und per Radiobutton kann man dort auswählen, welche Variante
zum Zug kommen soll. Dadurch werden alle drei Varianten gezeigt.

Ich hoffe, das ist für die nähere Zukunft ausreichend.

[EdAdvokat]

Hallo TurboMagic, schau doch noch mal über die Beispiele in Demos.
Dort habe ich zunächst nur bemerkt, dass die Sourcen in den dpr-Dateien nicht aufgeführt sind. Kann man selbst sicher nachbessern, doch wäre es günstig die gleich mit einzustellen.
Anbei nur die Cipher.dpr, doch auch in der Hash.dpr fehlen die Source-Verweise.
Ich habe mich zwischenzeitlich auch mit dem Projekt beschäftigt.
Zwar beackere ich nur ein Programmierfeld ganz am Fuße des delphischen Olymps, auf den ich gespannt und zugleich ehrfurchtsvoll schaue, doch oft sehe ich dabei
in die Sonne. Ungeachtet dessen tue ich es immer wieder.
Will sagen, dass ich eher ein lausiger Programmierer bin aber doch hier und da mal mich traue, eine Frage zu stellen. Nun tue ich dies:
AES bietet die Möglichkeit der Schlüsselstärken von 128, 192 und 256 kbit. In DEC soll diese Einstellung auch möglich sein und sich bestimmen anhand der eingegebenen Schlüssellänge.
Ich habe dies versucht und komme lediglich bis zu 16 Zeichen, also nur 128 kbit. Habe ich da ein Denkfehler?
Gebe ich eine Folge von 24 oder 32 Zeichen ein, nimmt er dies nicht an und wirft eine Exception.
Ich werde mir nun erst einmal die neue Version ansehen und ausprobieren.
In meinen bescheidenen Versuchen mit dem alten VCL_Progress habe ich für die von mir aufgenommenen Hash-Funktionen auch eine Progressbar installiert ganz einfach am Anfang
pb1.Position:=Min und am Ende pb1.Position:=Max und das geht auch, ist sicher was für meinen steinigen Acker auch Fuße des Olyms, doch bei der Ausführung erkennt man nicht, was
dahinter steckt. Da läuft nur so ein "dummer Strich" und zeigt an, dass da was gelaufen ist.
Da ich nun schon mal dabei bin: Sollte nicht noch mal kritisch über die verwendeten Hash-Funktionen geschaut werden, denn einige davon sind doch nicht mehr sicher bzw. werden
nicht mehr empfohlen (BSI-Empfehlungen). Sollten die weiterhin aufgenommen bleiben?
Wie ist es mit der Aufnahme von BCrypt? Ich habe damit etwas experimentiert. Anbei meine bescheidenen Versuche mit der alten Version.

[Jens01]

Hier!
habe ich mal gezeigt, wie man die Unit von Gammatester/ Wolgang Ehrhardt nutzen kann.

Frohes Neues Jahr!

[EdAdvokat]

vielen Dank Jens01.
Welche units von W. Erhardt hast Du da eingebunden? Alle die er unter AES veröffentlicht hat? Hast Du möglicherweise auch ein kurzes Beispielprogramm zu Deinen Funktionen?
Ich wünsche einen guten Rutsch ins Neue Jahr!

[Jens01]

Mit der Zeit muss ich die Methoden etwas geändert haben. Hier die letzte Version aus meinem Gesamtcode.
Sollten Dir die verlinkten Units fehlen, kann ich sie Dir geben.
Probier mal aus...

Delphi-Quellcode:

uses 
  TSC, Hash, Whirl512, fcaes256, AES_EAX, mem_util;

procedure GetSalt(var salt: TFCA256Salt);
{ -generate salt for key derivation }
// http://www.wolfgang-ehrhardt.de/crypt_en.html
var
  Ctr  : TCtrRec;
  TS   : TTimeStamp;
  sctx : THashContext;
  sdig : TWhirlDigest;
  qword: int64;
begin
  { Hash Date, Time, Randseed, size and free space (in byte) on active disk and (normally) TSC }
  _ReadCounter(Ctr);
  Whirl_Init(sctx);
  TS := datetimetotimestamp(now); { get date and time with millisecond precision }
  Whirl_Update(sctx, @TS.date, SizeOf(TS.date));
  Whirl_Update(sctx, @TS.time, SizeOf(TS.time));
  qword := disksize(0);
  Whirl_Update(sctx, @qword, SizeOf(qword)); { size of active disk }
  qword := diskfree(0);
  Whirl_Update(sctx, @qword, SizeOf(qword)); { free space on active disk }
  Whirl_Update(sctx, @Ctr, SizeOf(Ctr));
  Whirl_Update(sctx, @randseed, SizeOf(randseed));
  Whirl_Final(sctx, sdig);
  move(sdig, salt, SizeOf(salt));
end;

function Encrypt1(const AText: string; const APassword: string): string;
{ -Encrypt file InName to OutName using password }
// http://www.wolfgang-ehrhardt.de/crypt_en.html
const
  bufSize = $C000;
var
  N              : word;
  len            : int64;
  hdr            : TFCA256Hdr;
  cxe            : TAES_EAXContext;
  auth           : TFCA256_AuthBlock;
  TextOut, TextIn: TStringStream;
  buf            : array [0 .. bufSize - 1] of Byte;
begin
  randomize;
  TextIn  := TStringStream.Create(AText);
  TextOut := TStringStream.Create;
  try
    len := TextIn.Size;
    GetSalt(hdr.salt);

    if FCA_EAX256_initS(cxe, APassword, hdr) <> 0 then
      raise Exception.Create('Fehler'); // Abort('Internal error (FCA_EAX256_init)');

    TextOut.WriteBuffer(hdr, SizeOf(hdr));

    while len > 0 do
    begin
      if len > SizeOf(buf) then
        N := SizeOf(buf)
      else
        N := len;
      TextIn.ReadBuffer(buf, N);
      dec(len, N);
      if FCA_EAX256_encrypt(cxe, buf, N) <> 0 then
        raise Exception.Create('Fehler'); // Abort('Internal error (FCA_EAX256_encrypt)');
      TextOut.WriteBuffer(buf, N);
    end;
    FCA_EAX256_final(cxe, auth);
    TextOut.WriteBuffer(auth, SizeOf(auth));
    Result := Base64EncStr(TextOut.DataString);
  finally
    TextOut.Free;
    TextIn.Free;
  end;
end;

function Decrypt1(const AText: string; const APassword: string): string;
{ -Decrypt file InName to OutName using password sPW }
// http://www.wolfgang-ehrhardt.de/crypt_en.html
const
  bufSize = $C000;
var
  N              : word;
  I, len         : longint;
  hdrk           : TFCA256Hdr;
  hdrf           : TFCA256Hdr;
  cxe            : TAES_EAXContext;
  cxh            : TFCA_HMAC256_Context;
  authf          : TFCA256_AuthBlock;
  authc          : TFCA256_AuthBlock;
  UseEAX         : boolean;
  TextOut, TextIn: TStringStream;
  buf            : array [0 .. bufSize - 1] of Byte;
begin
  if AText = '' then
    Exit('');
  TextIn  := TStringStream.Create(Base64DecStr(AText));
  TextOut := TStringStream.Create;
  try
    len := TextIn.Size - SizeOf(hdrf) - SizeOf(authf);
    TextIn.ReadBuffer(hdrf, SizeOf(hdrf));

    if (hdrf.FCASig <> C_FCA_Sig) or (hdrf.Flags and $F0 <> $A0) then
      raise Exception.Create('Fehler'); // Abort('Invalid file header');

    if hdrf.Flags and $02 <> 0 then
    begin
      writeln(#7'*** Warning: Found zlib compression flag, use t_zlibex to inflate <outfile>');
    end;

    if not(hdrf.Flags and $04 <> 0) then
    begin
      raise Exception.Create('Fehler'); // writeln('Found: 256 bit key size');
    end;

    hdrk   := hdrf;
    UseEAX := odd(hdrf.Flags);
    if UseEAX then
    begin
      if FCA_EAX256_initS(cxe, APassword, hdrk) <> 0 then
        raise Exception.Create('Fehler'); // Abort('Internal error (FCA_EAX256_init)');
    end
    else
    begin
      if FCA_HMAC256_initS(cxh, APassword, hdrk) <> 0 then
        raise Exception.Create('Fehler'); // Abort('Internal error (FCA_HMAC256_init)');
    end;
    if hdrf.PW_ver <> hdrk.PW_ver then
      raise Exception.Create('Fehler'); // Abort('Wrong password');

    while len > 0 do
    begin
      if len > SizeOf(buf) then
        N := SizeOf(buf)
      else
        N := len;
      TextIn.ReadBuffer(buf, N);
      dec(len, N);
      if UseEAX then
      begin
        if FCA_EAX256_decrypt(cxe, buf, N) <> 0 then
          raise Exception.Create('Fehler'); // Abort('Internal error (FCA_EAX256_decrypt)');
      end
      else
      begin
        if FCA_HMAC256_decrypt(cxh, buf, N) <> 0 then
          raise Exception.Create('Fehler'); // Abort('Internal error (FCA_HMAC256_decrypt)');
      end;
      TextOut.WriteBuffer(buf, N);
    end;
    if UseEAX then
    begin
      FCA_EAX256_final(cxe, authc);
    end
    else
    begin
      FCA_HMAC256_final(cxh, authc);
    end;
    TextIn.ReadBuffer(authf, SizeOf(authf));
    for I := 0 to 15 do
    begin
      if authf[I] <> authc[I] then
      begin
        raise Exception.Create('Fehler'); // writeln(' Authentication failure!');
      end;
    end;
    Result := TextOut.DataString;
  finally
    TextOut.Free;
    TextIn.Free;
  end;
end;