Dateien verschlüssen mit Wolgang Ehrhardts Crypt-Units

[DieDolly]

Wolgang Ehrhardt hat sehr schöne aber für mich auch unverständliche Hash- und Crypt-Units.
Die Hash-Units benutze ich schon. Ich würde gerne eine Datei mit einem Passwort verschlüsseln.

Kann mir dazu einer ein Beispiel geben?

[TurboMagic]

Hallo,

ein Beispiel dafür habe ich dir dafür leider nicht.

Aber du könntest dir evtl. mal DEC anschauen, welches anders als
die Lösung des leider verstorbenen Wolfgang Erhards noch aktiv entwickelt
wird und bei dem auch einfache Beispiele dabei sind. Beinhaltet sowohl Hash-Algorithmen
als auch Verschlüsselungsalgorithmen und ist Cross Plattform kompatibel.

Zu finden hier:
https://github.com/MHumm/DelphiEncry...pendium/issues

Es kam erst am Sonntag ein neues Release davon raus.

Grüße
TurboMagic

[DieDolly]

Ist es mit DEC möglich mit nur einer einzigen Zeile eine Datei zu ver- und zu entschlüsseln?

Delphi-Quellcode:

DEC_Verschlüssle_Datei(BeispielAlgorithmus, Datei, Passwort)

?

Alles andere ist mir leider zuviel Aufwand und erzeugt nur wieder Chaos im Code.

Falls es das nicht gibt: das wäre ein guter Zusatz für DEC und meiner Meinung nach unverzichtbar.

[EdAdvokat]

schau doch mal nach bei J. Rathlev
https://www.rathlev-home.de/

dort findest Du den Link zu aeslib.zip und damit solltest Du durchaus weiter kommen.
Eine kleine Hürde ergibt sich aus der fehlenden Datei gnugettext.pas. Die findest Du jedoch auch unter:


https://www.delphipraxis.net/162828-...ttext-pas.html
und dort unter dem Beitragt #8.
Dies ist ein wirklich übersichtliches Programm mit dem Standardprogramm AES für eine sichere Chiffrierung.
Ich habe gute Erfahrungen mit dem AES-Algorithmus aus der lockbox und dem cn-pack gemacht und mir dazu
einen RTF-Editor mit div. Zusatztools zur AES-Chiffrierung, Hash-Tool und Packprogramm und div. Konvertierungen
geschrieben.Doch das ist sicher ein anderes Thema.

[generic]

Eine andere Variante wäre die LibSodium die gibt es auf verschiedenen Plattformen und Programmiersprachen.

[TurboMagic]

So, hier ein kurzes Beispiel zur Nutzung der DEC für den betreffenden Anwendungsfall.
Die relativen Pfade kommen aus dem Umstricken eines Demoprogramms auf den Anwendungsfall.
Braucht also mit Objekterzeugung und Freigabe 5 Zeilen. Dateien werden als Binärdateien
betrachtet, auch wenn das Beispiel eine Textdatei benutzt.

Delphi-Quellcode:

program Cipher_File;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  DECBaseClass in '..\..\Source\DECBaseClass.pas',
  DECCipherBase in '..\..\Source\DECCipherBase.pas',
  DECCipherModes in '..\..\Source\DECCipherModes.pas',
  DECCiphers in '..\..\Source\DECCiphers.pas',
  DECCRC in '..\..\Source\DECCRC.pas',
  DECFormat in '..\..\Source\DECFormat.pas',
  DECFormatBase in '..\..\Source\DECFormatBase.pas',
  DECTypes in '..\..\Source\DECTypes.pas',
  DECUtil in '..\..\Source\DECUtil.pas',
  DECData in '..\..\Source\DECData.pas',
  DECCipherFormats in '..\..\Source\DECCipherFormats.pas',
  DECUtilRawByteStringHelper in '..\..\Source\DECUtilRawByteStringHelper.pas',
  DECCipherInterface in '..\..\Source\DECCipherInterface.pas',
  DECDataCipher in '..\..\Source\DECDataCipher.pas';

var
  Cipher     : TCipher_AES;
begin
  Cipher := TCipher_AES.Create;

  try
    try
      // Schlüssel, Initialisierungsvektor, Füllwert um auf Blockgröße aufzufüllen
      Cipher.Init('Passwort', #1#2#3#4#5#6#7#64, 0);
      Cipher.Mode := cmCBCx;
      // Klartextdatei, verschlüsselte Datei
      Cipher.EncodeFile('test.txt', 'test.encr');

      ReadLn;
    except
      on E: Exception do
        Writeln(E.ClassName, ': ', E.Message);
    end;
  finally
    Cipher.Free;
  end;
end.

[DieDolly]

Ich kenne mich mit Verschlüsselung nicht aus. Der Vektor, ist das ein Wert den niemand sehen darf oder ist das egal?
Wie kommt dieser Vektor zustande? Kann ich da irgendwas hinschreiben?

Wenn das mit DEC nur 5 Zeilen sind, ist das OK.

[himitsu]

Der IV ist sowas ähnliches wie das SALZ, damit bei gleichem Passwort mit gleichen Daten nicht überall auf der Welt das selbe Ergebnis entsteht,
also ja, der ist "geheim" und für dich/in deinem Programm solltest du was Eigenes benutzten. (eventuell sogar für jede einzelne Verschlüsselung was Anderes)

https://de.wikipedia.org/wiki/Salt_(Kryptologie)
https://de.wikipedia.org/wiki/Initialisierungsvektor


Aber beim Ver- und Entschlüsseln natürlich jeweils das Gleiche. :angle2:


Stell dir den IV einfach so vor, wie bei einem Hash den Startwert, mit dem die Berechnung beginnt.

[DieDolly]

Wenn ich aus meinem Programm eine Datei verschlüsseln muss und das Programm an jemanden geben möchte, reicht es wenn der da das Passwort eingibt?
Oder muss der dann auch diesesIV eingeben?

[himitsu]

Du kannst den IV mitgeben,

aber er kann der Einfachheit halber auch "fest" im Programm eingebaut sein.



Die Summe aus IV und Key und Technik (Verschlüsselungsart/Modus, z.B. AES+CBC) ergibt die Verschlüsselung.
> wird Einwas geändert, ergibt es ein anderes Ergebnis

[DieDolly]

Klappt bisher genau so wie gewünscht.

Eine kleine Extra-Unit erlaubt mir dann an anderer Stelle einen 1-Zeiler als Aufruf. Die Extra-Unit ist aber ausbaufähig was doppelten Code angeht.
Dieses .encrypted.txt und .decrypted.txt ist nur eine kleine Hilfe für mich bis ich alles richtig habe.

Delphi-Quellcode:

unit Utils.DEC.Crypt;

interface

uses
 System.SysUtils, System.Classes, DECCipherBase, DECCiphers, DECCipherFormats;

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

implementation

class function TDECCryptUtils.AESFileEncrypt(const FileName, Password: string): string;
var
 Cipher: TCipher_AES;
begin
 Cipher := TCipher_AES.Create;
 try
  try
   // Schlüssel, Initialisierungsvektor, Füllwert um auf Blockgröße aufzufüllen
   Cipher.Init(Password, #1#2#3#4#5#6#7#64, 0);
   Cipher.Mode := cmCBCx;
   // Klartextdatei, verschlüsselte Datei
   Cipher.EncodeFile(FileName, FileName + '.encrypted.txt');
  except
   //
  end;
 finally
  Cipher.Free;
 end;
end;

class function TDECCryptUtils.AESFileDecrypt(const FileName, Password: string): string;
var
 Cipher: TCipher_AES;
begin
 Cipher := TCipher_AES.Create;
 try
  try
   // Schlüssel, Initialisierungsvektor, Füllwert um auf Blockgröße aufzufüllen
   Cipher.Init(Password, #1#2#3#4#5#6#7#64, 0);
   Cipher.Mode := cmCBCx;
   // Klartextdatei, verschlüsselte Datei
   Cipher.DecodeFile(FileName, FileName + '.decrypted.txt');
  except
   //
  end;
 finally
  Cipher.Free;
 end;
end;

end.

[TurboMagic]

Schön, dass DEC nützlich ist.

Evtl. hält das sogar in GetIt EInzug, da laufen aber nich die Diskussionen
wegen Exportbeschränkungen für cryptographische Algorithmen.
Wenn das so nicht klappt, wird's eine DEC Light für GetIt geben wo dann
halt alles außer den Verschlüsselungsalgorithmen drin ist.
Auch Hashes, CRCs und Zufallszahlengeneratoren sind für den einen oder
anderen nützlich...

[DieDolly]

Eine letzte Frage habe ich noch da ich gerade gesehen habe dass man auch den Fortschritt anzeigen lassen kann.
Wie funktioniert das? Eine ProgressBar brauche ich nicht. Ich würde mir gerne ausgeben lassen, wieviele Bytes von der Datei schon verschlüsselt wurden.

[DieDolly]

Geht das nicht? :(

[himitsu]

Schau doch mal in TCipher_AES?

Ob es im Constructor oder eine Methode einen Setter gibt, oder vielleicht gibt es auch ein Property, wo man eine Ereignismethode oder ein Interface zuweisen kann.


[Edit]
Es gibt ein IDECProgress, aber scheinbar nur beim Ver-/Entschlüsseln von Streams
und im Prinzip auch von Dateien (TFileStream).

[Edit2]
Wer die das CodeInsight lesen kann, ist klar im Vorteil. :zwinker:

Delphi-Quellcode:

procedure DecodeFile(const SourceFileName, DestFileName: string;
                     const Progress: IDECProgress = nil);

[DieDolly]

Dass das da drin steht weiß ich aber ich habe keine Ahnung wie man das benutzt.
In den Demos steht davon auch nix.

[himitsu]

Beispiel:

Delphi-Quellcode:

type                    
  TForm1 = class(TForm, IDECProgress)
    ...
  private
    procedure Process(const Min, Max, Pos: Int64); stdcall;
  end;

Und dann Self in als Interface für den Callback reingeben.



Man kann sich auch ein eigenes Objekt/Interface dafür bauen.
TForm, bzw. alle TComponent haben bereits eine Interfacebehandlung dind, welche standardmäßig keine Referenzzählung besitzt. (Controlle über die Freigabe liegt weiter beim Owner und/oder Free)

Und wer selber kein komplettes IInterface bauen will:
TInterfacedObject
TInterfacedPersistent
...


Und da du keine Objektinstanz zur Verfügung hast, sondern nur Prozeduren, bzw. nur statische Methoden,
würde ich das Interface durchreichen, also

Delphi-Quellcode:

; const Progress: IDECProgress = nil

in die eigenen Methoden mit einbauen.

[DieDolly]

Verstehe ich nicht. Das funktioniert so nicht. Bin ich zu dumm dafür?

Wieso kann das nicht einfach eine normale CallBacl-Funktion sein? Irgendwie viel zu kompliziert das DEC was den Progress angeht.

Delphi-Quellcode:

procedure TDECCryptFunctions.Process(const Min, Max, Pos: Int64);
begin

end;

class function TDECCryptUtils.AESFileDecrypt(const FileName, Password: string): string;
var
 Cipher: TCipher_AES;
begin
 Cipher := TCipher_AES.Create;
 try
  try
   // Schlüssel, Initialisierungsvektor, Füllwert um auf Blockgröße aufzufüllen
   Cipher.Init(Password, #1#2#3#4#5#6#7#64, 0);
   Cipher.Mode := cmCBCx;
   // Klartextdatei, verschlüsselte Datei
   Cipher.DecodeFile(FileName, FileName + '.decrypted.txt', Process);
  except
   //
  end;
 finally
  Cipher.Free;
 end;
end;

[himitsu]

Du hast eine Class-Procedure und da es dort keine "Instanz" gibt, hast du da auf Process garkeinen Zugriff.
Und nochmals, hier gibt man eine Interface-"Instanz" rein und keinen "Methoden"-Zeiger. (bei meinem Beispiel mit TForm1 also Form1 bzw. Self)
Du brauchst also erstmal ein Objekt und das muß erzeugt worden sein (Create).
Es wird die Instanz reingegeben und was aufgerufen wird (Process), darum kümmert sich das Interface (IDECProgress).

Callback-Interfaces sind nichts Besonderes und sie sind auch erfolgreich/problemlos sehr weit verbreitet.

Klar, da hier (aktuell) nur eine Methode drin steckt, sieht es "unpraktisch" aus, aber das ändert sich schnell, sobald es etwas "komplexer" wird.
Nur ein Zeiger für mehrere Ereignisse:

Delphi-Quellcode:

type 
  IComplexProgress = interface
    procedure Start(const Min, Max: Int64);
    procedure Process(const Pos: Int64; var Cancel: Boolean);
    procedure Stop;
    procedure Error(const Message: string);
  end;

Beschweren wird sich auch immer wer, da es nie Jedem gerecht gemacht werden kann, bei all den Möglichkeiten.
* Callback-Objekt (interface ODER class)
* Prozedur (procedure ODER class procedure static)
* Methode (procedure of object)
* anonyme Methode ODER die beiden Vorherrigen (reference to procedure), aber dafür kann man diese Zeiger "oft" garnicht vergleichen

[DieDolly]

Ich verstehe nur Bahnhof. Wo muss ich das denn hinpacken was da oben steht und wie wende ich das an?
Normale CallBacks schickt der Himmel. Interfaces die Hölle.
Ne also wenn das so kompliziert ist, nicht es nicht einmal einen normalen CallBack gibt, dann ist das DEC nix für mich.

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

[Jens01]

Beispiel:

Delphi-Quellcode:

var
  KlarText, VerschluesselterText: string;

begin
  KlarText := 'Testtext';
  VerschluesselterText := Encrypt1(KlarText, '123456');

  KlarText := Decrypt1(VerschluesselterText, '123456');
  
  SameStr(KlarText, 'Testtext'); 
end;

[EdAdvokat]

vielen Dank Jens01. Ich habe die angegebenen units zusammengesucht und hoffe, trotz der unterschiedlichen Erstellungsdaten, dass alles funktionieren wird.
Mal sehen wann ich dazu komme, das Beispiel auszuprobieren. Ich habe mal immer wieder versucht, mit seinen vielen Dateien etwas Sinnvolles in Richtung Crypto hinzubekommen, doch
es ist mir leider nicht geglückt. die anderen Mathe-units sind auch toll. Leider gibt es den hervorragenden "Gammatester" nun nicht mehr.

Jetzt habe ich ja viele neue Aufgaben mit Deinem Beispiel und auch mit der Testung des DEC-Projektes, mit dem ich noch so einige Probleme habe.
Man glaubt ja nicht, was so eine einfache Progressbar-Applikation für Mühe machen soll und nach all dieser Mühe bleibt der grüne Balken nach der erfolgreichen Beendigung des Programmteils einfach so bei 100% stehen, statt wieder auf 0 zu gehen. Da muß doch noch was möglich sein (ggf. delay(2000) pb1.position:=min;). Sicher ist das nicht die hohe Form der Autoren des DEC-Projektes.

Nun wird eine Flasche oder zwei Bier aufgemacht und das Neue Jahr erwartet. Euch allen einen guten Rutsch:)

[TurboMagic]

Zitat:

Zitat von EdAdvokat (Beitrag 1480117)

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.

Hallo,

hier auf die Schnelle ein paar Anmerkungen:

1. Die Sourcen sind nicht mehr in den dpr Dateien aufgelistet, nach dem himitsu Änderungen eingereicht hat und man
nun den Source Unterordner in den Suchpfad/Bibliothekspfad der IDE einträgt. Dann findet er die auch. Zumindest
für den Bibliothekspfad sollte es im Entwicklungszweig ein Kommandozeilenprogramm geben (Unterordner Install),
welches das für alle installierten IDE versionen ab D2009 übernimmt.

2. Das mit dem AES muss ich mir anschauen. Lt. Code sollte es eigentlich anhand der Schlüssellänge die Rundenzahl
ausrechnen (soweit ich das auswendig im Kopf habe). Was für eine Exception wird geworfen?
Könntest du evtl. auf Github ein "issue" dafür aufmachen?

3. Das mit der Fortschrittsanzeige wurde gestern im Entwicklungszweig umgebaut und heute wurde die PDF-Doku
aktualisiert. Auch das VCL-Demo Programm dazu wurde angepasst. Kannst du dir das nochmal anschauen?
Würde bei Bedarf gerne vom aktuellen STand aus diskutieren wollen.

4. Die bereits umgesetzten Hash-Funktionen sollten erhalten bleiben, auch wenn manche inzwischen als Unsicher
gelten. Warum? Aus Kompatibilitätsgründen! Es sollte halt jeweils vermerkt werden, wenn eine unsicher ist.
Was ja glaube ich soweit ich's weiß in den XMLDOC Kommentaren schon geschehen ist. Evtl. kann man's noch
deutlicher machen in dem man zur DOku eine Liste hinzufügt.

5. Ja, es gibt den Plan Bcrypt mal irgendwann aufzunehmen. Eins nach dem anderen ;-)
Wie du dem letzten Commit entnehmen kannst hab' ich mal damit begonnen den noch fehlenden SHA2-224
nachzurüsten, bin aber noch nicht weit. Also: eines nach dem anderen ;-)
Vor BCrypt wäre SHA3 auch noch auf dem Plan und bei BCrypt gibt's ja glaube ich dummerweise mehrere
Versionen...

Grüße
TurboMagic

[TurboMagic]

Hallo,

so wie seit gestern Abend im Entwicklugnszweig die neue Umsetzung ist, bekommst du sauber mit, wenn's zuende ist
und kannst dann tun was immer du auch willst...

Grüße und guten Rutsch
TurboMagic

[EdAdvokat]

Hallo TurboMagic, habe mich bemüht ein neues Thema in Github anzulegen und mein Problem mit der Schlüssellänge zu schildern. Hoffentlich habe ich mich nicht zu blöd dabei angestellt.

Schauen wir im Nächsten Jahr weiter. Alles Gute und einen guten Rutsch für alle:)

[TurboMagic]

Hallo,

ich habe jetzt versucht den Fehler nachzustellen, aber erfolglos.
Siehe GitHub Bugreport.

Frage: was mache ich anders als du?

Grüße
TurboMagic

[EdAdvokat]

Hallo TurboMagic,
Ich habe das von Dir verwendete Password "Passwort1234567890" in das Demoprogramm Progress_VCL als Key eingesetzt und danach kommt die bereits erwähnte Exception.
Mache ich da möglicherweise was falsch?
Das Passwort habe ich dort im Programm selbst also nur um das Wort Passwort erweitert und dann die bereits enthaltenen Ziffern 1..0, also insgesammt über 16 Zeichen erweitert.

[TurboMagic]

Ändere mal die betroffene Zeile wie folgt ab:

Delphi-Quellcode:

Cipher.Init(RawByteString('Passwort1234567890'), RawByteString(#1#2#3#4#5#6#7#99), 0);

Dadurch wird die andere Variante der Init Methode aufgerufen.
In deinem Fall wurde immer die WideString Variante aufgerufen und die hat halt, da
WideString ja auch UTF16 basierend ist, immer 0-Bytes als Füllbytes für die Zeichen, die
weniger als 8-Bit zur Codierung benötigen.

Ich werde diese Änderung der Demo auch committen.

[EdAdvokat]

Danke TurboMagic, nun klappt es wieder und er nimmt den längeren Key an. Es ist schon sehr interessant, was für Klippen es so gibt.
Ich bin also gespannt auf die nächsten Änderungen und Ergänzungen im DEC-Projekt.
Ich wünsche dem DEC-Team weiterhin gute Einfälle für das interessante Projekt.

[DieDolly]

Zitat:

Zitat von TurboMagic (Beitrag 1480112)

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.

Edit
Hat sich erledigt ich musste nur in den anderen Branch gehen. Sorry, Github-Neuling
https://github.com/MHumm/DelphiEncry...L/MainForm.pas

Erst einmal danke für all die Mühen. Meinst du diese Demo? https://github.com/MHumm/DelphiEncry...L/MainForm.pas



:thumb::thumb::thumb: