DEC6.0 Verständnisfrage AES Ver-/Entschlüsselung

[Aviator]

Hallo Delphianer,

ich nutze zum ersten Mal DEC in der Version 6.0. Zuvor habe ich noch nicht mit dem DEC gearbeitet und daher auch keine Vorkenntnisse darüber. Besonders viel findet man darüber aktuell auch (noch) nicht im Netz, da die Version ja recht frisch ist. Oder ich hab falsch gesucht.

Konkret geht es mir darum, dass ich eine Verschlüsselung (und logischerweise auch Entschlüsselung) per AES machen möchte. Ich bin auch mittlerweile so weit, dass das Ver- und Entschlüsseln funktioniert, habe aber den Verdacht, dass das einfacher funktionieren muss und ich nur auf dem Schlauch stehe. Vor allem dieses dauerhafte Umwandeln von

Delphi-Quellcode:

TArray<Byte>

in

Delphi-Quellcode:

string

und umgekehrt kommt mir recht aufwendig vor. Ich vermute ich kenne einfach nur die Kniffe noch nicht die man anwenden kann.

Speichern wollte ich den verschlüsselten String nachher im Base64 Format in einer JSON Datei. Der IV für die Verschlüsselung wird einfach als Byte Array vor den eigentlichen verschlüsselten Text gehängt. Das funktioniert auch schon.

Beim Entschlüsseln bekomme ich allerdings immer den String mit #0 nach den einzelnen Chars zurück. Ich tippe hier nur auf ein Problem mit den Encoding, konnte aber mit meinen Versuchen keine Lösung erzielen.

Kann mal jemand über meine Klasse und auch die Aufrufe der Methoden drüber schauen und mir ggf. einen Tipp geben was ich besser machen kann?

Delphi-Quellcode:

unit Common.Encryption.AES;

interface

uses
  Common.Interfaces.Aes, Common.Interfaces.AesKeyReader, DECCiphers, DECRandom, System.SysUtils, Logger.Interfaces,
  Logger.Enumerations, Logger.Helpers, DECCipherBase, System.Classes, System.Generics.Collections;

type
  TAes = class(TInterfacedObject, IAes)
  private
    FAesKeyReader: IAesKeyReader;
    FLogger: ILogger;
  public
    constructor Create(Logger: ILogger; AesKeyReader: IAesKeyReader);
    function Decrypt(Cipher: TArray<Byte>): string;
    function Encrypt(PlainText: string): TArray<Byte>; overload;
    function Encrypt(PlainText: string; IV: TArray<Byte>): TArray<Byte>; overload;
  end;

implementation

{ TAes }

constructor TAes.Create(Logger: ILogger; AesKeyReader: IAesKeyReader);
begin
  inherited Create;

  FLogger := Logger;
  FAesKeyReader := AesKeyReader;
end;

function TAes.Decrypt(Cipher: TArray<Byte>): string;
const
  IV_LEN = $10;
var
  AES: TCipher_AES;
  iv, data: TBytes;
  ms: TBytesStream;
  decrypted: TArray<Byte>;
begin
  try
    AES := TCipher_AES.Create;
    try
      ms := TBytesStream.Create(Cipher);
      try
        SetLength(iv, IV_LEN);
        if (ms.Read(iv, IV_LEN) = IV_LEN) then begin
          AES.Mode := cmCBCx;
          AES.Init(FAesKeyReader.GetAesKey, iv);

          SetLength(data, ms.Size - IV_LEN);
          if (ms.Read(data, ms.Size - IV_LEN) = ms.Size - IV_LEN) then begin
            decrypted := AES.DecodeBytes(data);
            Result := TEncoding.Default.GetString(decrypted);
          end;
        end;
      finally
        ms.Free;
      end;
    finally
      AES.Free;
    end;
  except
    on e: Exception do begin
      Result := EmptyStr;
      TLogHelper.LogMessage('Error decrypting given cipher: %s', [e.Message], lcError, FLogger);
    end;
  end;
end;

function TAes.Encrypt(PlainText: string): TArray<Byte>;
var
  IV: TArray<Byte>;
begin
  IV := RandomBytes($10);
  Result := Encrypt(PlainText, IV);
end;

function TAes.Encrypt(PlainText: string; IV: TArray<Byte>): TArray<Byte>;
var
  AES: TCipher_AES;
  Res: TArray<Byte>;
begin
  try
    AES := TCipher_AES.Create;
    try
      AES.Mode := cmCBCx;
      AES.Init(FAesKeyReader.GetAesKey, IV);
      Res := AES.EncodeStringToBytes(PlainText);
      SetLength(Result, Length(Res) + Length(IV));
      TArray.Copy<Byte>(IV, Result, 0, 0, Length(IV));
      TArray.Copy<Byte>(Res, Result, 0, Length(IV), Length(Res));
    finally
      AES.Free;
    end;
  except
    on e: Exception do begin
      Result := nil;
      TLogHelper.LogMessage('Error encrypting given string: %s', [e.Message], lcError, FLogger);
    end;
  end;
end;

end.

Die Funktion

Delphi-Quellcode:

FAesKeyReader.GetAesKey()

ruft nur den AES Key ab und lädt diesen von der Festplatte. Rückgabe ist in dem Fall auch ein

Delphi-Quellcode:

TArray<Byte>

.

Der aktuelle Testschlüssel mit dem ich verschlüssele sieht so aus (Byte Folge):

Delphi-Quellcode:

C9 58 F5 C6 26 1C A9 C6 3D 55 AE 1F AE A5 03 39 07 06 2E 8F 90 FF AA 13 2C 56 5E 32 3C 83 B3 48

.
Input ist das Wort

Delphi-Quellcode:

TestString

welches im Zwischenschritt vor dem Base64Encode Aufruf (also nur mit der AES Verschlüsselung) die folgende Byte-Folge zurückgibt:

Delphi-Quellcode:

F3 CA 54 23 0C DF 17 72 C1 94 5D 17 07 4F 8D 14 8A DF 7B 8C 71 D1 92 BD 4B 69 54 75 F1 A9 BF 2E 5B F0 66 E9

.
Der verwendete InitVector sieht so aus:

Delphi-Quellcode:

F3 CA 54 23 0C DF 17 72 C1 94 5D 17 07 4F 8D 14

.
Base64Encoded sieht das dann so aus:

Delphi-Quellcode:

88pUIwzfF3LBlF0XB0+NFIrfe4xx0ZK9S2lUdfGpvy5b8Gbp

.

Wenn ich den Base64 String nun wieder zurückwandele und das Ergebnis von

Delphi-Quellcode:

FAes.Decode()

zurück kommt, dann erhalte ich dieses Ergebnis:

Delphi-Quellcode:

'T'#0'e'#0's'#0't'#0'S'#0't'#0'r'#0'i'#0'n'#0'g'#0

.
Also den korrekten String nur eben mit #0 nach jedem einzelnen Char.

Der Aufruf der Methoden geschieht damit. Und hier vermute ich mein Problem und denke auch, dass das einfacher gehen müsste.

Delphi-Quellcode:

FAes

ist eine Instanz vom Typ

Delphi-Quellcode:

IAes

.

Delphi-Quellcode:

var
  s: string;
  Base64Decoded: TArray<Byte>;
  Result: string;

begin
  s := TEncoding.Default.GetString(TNetEncoding.Base64.Encode(FAes.Encrypt('TestString')));
  Base64Decoded := TNetEncoding.Base64.Decode(TEncoding.Default.GetBytes(s));
  Result := FAes.Decrypt(Base64Decoded);
end;

[EdAdvokat]

Hallo Aviator,
nachdem TurboMagic einige Fehlerkorrekturen am DEC 6.0 vorgenommen hat, habe ich gleich mal mit dem letzten Stand des DEC (09.02.2021) etwas herumprobiert.
Damit ist es möglich, eine Klartextdatei mit AES zu verschlüsseln/entschlüsseln. Zugleich habe ich die verschiedenen Betriebsmodi integriert und auch einige Hash-Tools mit
gegeben. Einfach mal darüberschauen. Da Markus (TurobMagic) eine ähnliche Demo bereits erstellt hat, gehe ich davon aus, dass es auch im Sinne des "Schöpfers" ist.
Seine Intension für die Demo war zwar eher die Verwendung des Progress-Balkens.

[EdAdvokat]

irgendwas mit dem Hochladen der Datei hat nicht geklappt. Hier nochmals ein Versuch.

[DieDolly]

Irgendwie sehr kompliziert diese Demo.
Ich verschlüssle gerade eine 25 GB große Datei und der visuelle Progress ist halt "nicht da".

[EdAdvokat]

25 GB ist ja fast das gepackte deutsche Internet:)
Da wirft das Programm klar die Hufe hoch. Ich habe es ebenfalls probiert. Doch mit einer Datei 407 MB läuft die Sache wie die Polizei in die Häuser...:)
Was ist denn so kompliziert an dem Programm?

[DieDolly]

Ich verstehe, wie man eine Datei reinlädt, sie ver- und entschlüsselt. Der Rest ist ein Geheimnis für mich.

[TurboMagic]

Habe mir den Anhang noch nicht anschauen können, empfehle aber aus verschiedenen Gründen den Development Zweig zu nutzen.

Dort ist das mit dem Progress schon so umgebaut wie es mit V6.1 veröffentlicht werden wird. Sollte einfacher als das aus DEC 6.0 sein. Und ja ein einfaches Demo Programm ist da auch dabei.

Zu Base64: in der Format.pas ist da was passendes für drin...
Und Methoden die auf RawByte Strings arbeiten sind auch vorhanden, da sollte es auch keine Unicode String #0 Probleme geben.

[EdAdvokat]

die in #3 hochgeladene Demo ist auf Basis der Version 6.1 von DEC (Develelopment-Zweig) erstellt worden. Hinsichtlich der Progress-Funktion habe ich mich für die 3. Variante "anonymous method as progress event" entschieden. Auch die anderen in der Demo von TurboMagic aufgeführten Varianten wären möglich.
Die Demo ist also auf dem neusten Stand des DEC 6.1.

[Aviator]

Ich schaue mir die Format.pas morgen mal genauer an sofern ich die Zeit dazu finde. Danke schonmal für den Hinweis. Um das Verschlüsseln einer Datei geht es hier nicht im Geringsten sondern um das Verschlüsseln eines einzelnen Strings.

[Rollo62]

Zitat:

Zitat von DieDolly (Beitrag 1482720)

Der Rest ist ein Geheimnis für mich.

Genau das ist ja der Sinn der Sache :-D

[DieDolly]

Damit meine ich das UI.

[himitsu]

Zitat:

Zitat von DieDolly (Beitrag 1482809)

Zitat:

Zitat von Rollo62 (Beitrag 1482808)

Zitat:

Zitat von DieDolly (Beitrag 1482720)

Der Rest ist ein Geheimnis für mich.

Genau das ist ja der Sinn der Sache :-D

Damit meine ich das UI.

Klar,

denn vom Code her sollte es ja kein Geheimnis sein.
"security through obscurity" ist nicht per se sicher.

Es ist bekannt, damit kann auch jeder nach Schwachstellen oder absichtlichen Hintertüren schauen,
aber es muß schwer/aufwändig/langsam genug sein, damit man es dennoch nicht so laucht aufbekommt.

[Aviator]

Zitat:

Zitat von TurboMagic (Beitrag 1482723)

Zu Base64: in der Format.pas ist da was passendes für drin...
Und Methoden die auf RawByte Strings arbeiten sind auch vorhanden, da sollte es auch keine Unicode String #0 Probleme geben.

Ich habe mir die DECFormats.pas jetzt mal angeschaut. Allerdings finde ich da jetzt nicht wirklich einen passenden Funktionsaufruf um mein Problem zu lösen. Kannst du mir da noch etwas auf die Sprünge helfen?
[EDIT] Zudem wäre die Frage, ob diese ganze hin und her Konvertiererei da sein muss oder ob das noch einfacher geht. Daher nochmal die Bitte ob sich jemand, der sich nicht über irgendeine UI und obfuscated Code auslassen will, mal meine Klasse in meinem ersten Post anschauen und was dazu sagen kann.[/EDIT]

Ich habe mir aktuell mal damit beholfen, dass ich alle #0 Chars aus meinem String entferne. Aber das ist ja nicht die Lösung. Wichtig ist nochmal, dass ich keine Datei sondern nur einen einfachen String AES verschlüsseln möchte.

[TurboMagic]

Hallo,

probiere mal den Ansatz (ungetestet):

Delphi-Quellcode:

function TAes.Encrypt(PlainText: string; IV:TBytes):string;
var
  AES: TCipher_AES;
  Res: TArray<Byte>;
begin
  try
    AES := TCipher_AES.Create;
    try
      AES.Mode := cmCBCx;
      AES.Init(FAesKeyReader.GetAesKey, IV);
      result := DECFormat.TFormat_Base64.Encode(IV + AES.EncodeStringToBytes(RawByteString(PlainText)));
    finally
      AES.Free;
    end;
  except
    // snip
  end;
end;

Liefert gleich alles in Base64 zurück.
Seit XE7 kann man Arrays auch einfach so verketten...

[Aviator]

Also mit der Lösung zum Verschlüsseln funktioniert dann auch das Entschlüsseln ohne die #0 Chars. Danke! :thumb:
Allerdings bleibe ich bei der Base64 Encode Methode aus System.NetEncoding, da die mir direkt einen String zurückgibt den ich dann weiterverarbeiten/speichern kann.

Was mir noch etwas Sorge bereitet ist das Trennen des IVs von den eigentlichen Nutzdaten. Wird dafür wirklich ein Stream benötigt oder gibt es hierfür auch einen einfacheren Weg wie beim Verknüpfen von zwei Byte Arrays?

[TurboMagic]

Hallo,

ich glaube es gibt auch Delete für Arrays seit XE7.
Damals gab's da mehr neues zu Arrays.

Grüße
TurboMagic

[EdAdvokat]

Das Experimentieren mit dem neuen DEC-Projekt 6.1 hat schon seinen Reiz.
Nachdem die Frage nach einer Lösung für encrypt/decrypt von Strings aufgeworfen wurde, habe ich dies mit der Methode EncodeStringToString gelöst
und es funktioniert auch.
Sicher war das wohl nicht sehr anspruchsvoll. Doch hier im Forum wurde die Anwendung der Methode EncodeBytes behandelt und so habe ich mich auch daran
versucht, jedoch bislang ohne durchgreifenden Erfolg.
Zunächst habe ich eine Konsolenanwendung mit EncodeBytes erstellt und die funktioniert auch. Dann wollte ich diese in eine VCL-Anwendung umsetzen und
da tauchten die Probleme auf.
Das Problem scheint die Umwandlung von TArray<Byte> in string für eine Ausgabe des verschlüsselten Textes zu sein und natürlich auch dann wieder
das gleiche Problem zurück bei der Decryptierung.
Ist der Ansatz überhaupt tragfähig, die Konsolenanwendung zur Grundlage zu nehmen? Die hier im Forum dargestellten Beispiele haben mich nicht so richtig
weiter gebracht, denn ich backe eher noch "kleine Brötchen" und mache das alles nur als Hobby mit eher mäßigem Erfolg, doch es reizt mich immer wieder.
Was ist das Besondere an der Methode EncodeBytes? Ist die wesentlich besser als die Methode EncodeStringToString?
Ich wäre daher sehr interessiert an einer Lösung der DEC-Verschlüsselung/Entschlüsselung mit der Methode EncodeBytes im VCL-Programm so etwa mit ButtonClick
auf encode und decode...
Anbei meine bescheidenen Versuche als Konsolenanwendung:

Delphi-Quellcode:

program Format_Console;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  DECFormat,
  DECCipherBase,
  DECCipherModes,
  DECCipherFormats,
  DECCiphers;

var
  Cipher     : TCipher_AES; 
  SourceText : RawByteString;
  CipherKey  : RawByteString;
  IV         : RawByteString;
  Input,
  Output     : TBytes;
  i          : Integer;

begin
  Cipher := TCipher_AES.Create;
  try
    try
      CipherKey := 'Passwort';
      IV := #0#0#0#0#0#0#0#0;
      Cipher.Init(CipherKey, IV, 0);
      Cipher.Mode := cmCBCx;
      SourceText := 'AES Bytes Beispiel';
      WriteLn('Source text: ' + SourceText);
      Input := System.SysUtils.BytesOf(SourceText);

      // Encrypt
      Output := Cipher.EncodeBytes(Input);
      Write('Encrypted data in hex: ');
      for i := 0 to high(Output) do
        Write(IntToHex(Output[i], 2), ' ');

      WriteLn;

       // Decrypt
      Cipher.Init(CipherKey, IV, 0);
      Output := Cipher.DecodeBytes(Output);
      SourceText := RawByteString(System.SysUtils.StringOf(Output));
      WriteLn('Decrypted data: ' + SourceText);

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

und in der VCL-Anwendung:

Delphi-Quellcode:

procedure TForm1.btn15Click(Sender: TObject);  //enc bytes
var
  Cipher: TCipher_AES;
  Res: TArray<Byte>;
  CipherKey : RawByteString;
  sourceText : RawByteString;
  Input,
  Output     : TBytes;
  i          : Integer;
begin
  try
    Cipher := TCipher_AES.Create;
    try
      Cipher.Mode := cmCBCx;
      CipherKey := 'Passwort';
      //IV := #0#0#0#0#0#0#0#0;
      Cipher.Init(CipherKey);
      SourceText := 'Beispielklartext AES';     
      Input := System.SysUtils.BytesOf(SourceText);
      Res := Cipher.EncodeBytes(Input);
      for i := 0 to High(Res[i]) do
        (mmodecstr.text:=(IntToHex(Res[i], 2)));
    finally
      Cipher.Free;
    end;
  except
    // Fehlerbehandlung später
  end;

procedure TForm1.btn13Click(Sender: TObject); //dec Bytes
var Cipher     : TCipher_AES;
  SourceText : RawByteString;
  CipherKey  : RawByteString;
  IV         : RawByteString;
  Input,
  Output     : TBytes;
  i          : Integer;
  out        : string;
  Hexwerte   : TArray<Byte>;

begin
      Cipher := TCipher_AES.Create;
      CipherKey := 'Passwort';
      IV := #0#0#0#0#0#0#0#0;
      Cipher.Init(CipherKey, IV, 0);
      Cipher.Mode := cmCBCx;
      //HexWerte := 56 5B 08 BE A7 D2 4C D7 7C 30 D2 2E EA BF 79 1F 5F 88 F0 80; (über showMessage abgeschrieben)
      Output := Cipher.DecodeBytes(HexWerte); //klappt natürlich nicht

      SourceText := RawByteString(System.SysUtils.StringOf(Output));
      mmodec1.text:= ('Decrypted data: ' + SourceText);
end;

[Aviator]

Naja das hat zwar jetzt eigentlich nicht direkt etwas mit meiner Ausgangsfrage zu tun, aber folgendes ist ja das Problem.

Du verschlüsselst einen beliebigen String. Durch die Verschlüsselung werden Zeichen bzw. Blöcke in unterschiedlichste Byte Abfolgen verschlüsselt die keine lesbaren Zeichen darstellen. Daher auch meine Vorgehensweise mit Base64. Base64 kodiert einen String so, dass die Zeichen immer und überall gelesen, gespeichert und übertragen werden können ohne, dass bspw. irgendwelche Steuerzeichen wie #13 und #10 oder Escape (#27) darin vorkommen die Probleme bereiten könnten.

Ich habe mir die Ausgabe deiner beiden Anwendungen jetzt nicht direkt angeschaut, aber ich vermute mal einfach, dass die Konsolenanwendung durch den ohnehin schon kleineren Zeichensatz da irgendwelche kryptischen Zeichen mit reinhaut die für dich aussehen als würde es "funktionieren".

Ich kann jetzt aber auch komplett daneben liegen, da ich mit dem Thema Verschlüsselung erst recht kurz arbeite und dadurch auch nicht direkt Profi in dieser Sache bin. Ich hatte in C# die Berührungspunkte damit und wollte das nach Delphi übertragen, aber C# hat da von Haus aus schon deutlich mehr und einfacher zu verwendende Methoden. Zumindest empfinde ich das so.

[EdAdvokat]

vielen Dank für die schnelle Reaktion.
Das Konsolenprogramm, wie gepostet liefert Hex-werte und daher keine Steuerzeichen. Es funktioniert tatsächlich es entschlüsselt tatsächlich den verschlüsselten string.
Bei meiner Lösung mit EncodeStringToString habe ich das Ergebnis der Verschlüsselung von String in Hex gewandelt und dann zurück bei der Decryptierung wieder von Hex in string.
Das hat geklappt.
Für die EncodeByte-Lösung wäre es mir auch egal ein anderes Ausgabeformat zu wählen, wenn ich nur wüßte wie das konkret geht.

[TurboMagic]

Zitat:

Zitat von Aviator (Beitrag 1482928)

Ich kann jetzt aber auch komplett daneben liegen, da ich mit dem Thema Verschlüsselung erst recht kurz arbeite und dadurch auch nicht direkt Profi in dieser Sache bin. Ich hatte in C# die Berührungspunkte damit und wollte das nach Delphi übertragen, aber C# hat da von Haus aus schon deutlich mehr und einfacher zu verwendende Methoden. Zumindest empfinde ich das so.

Die Erklärung war ja schon ganz gut so. Mit Strings kann man sich halt schnell Zeichensatzkonvertierungsprobleme etc. einfangen und
TBytes wird auf alle Fälle dann benötigt, wenn binäre Daten wie Bilder verschlpüsselt werden sollen.

Tiefer steige ich jetzt mal gerade nicht ein, da ich gerade noch an der DEC 6.1 Lite für GetIt arbeite...

Meine Frage wäre, was C# da an einfacher zu verwendende Methoden bietet?
In Punkto Kryptographie oder in Punkto String vs. Byte Arrays etc. und deren Umwandlung?

Grüße
TurboMagic

[DieDolly]

Was wird der Unterschied zwischen DEC 6.1 und DEC 6.1 Lite sein?
Wirst du die Lite-Version auch auf GitHub einstellen? Ich kann mit getit nix anfangen und will das auch nicht.

[TurboMagic]

Naja, die Lite wird zwar als Release auch auf GitHub auftauchen, aber wenn du
die normale benutzt bist du besser bedient. In der Lite fehlen nämlich alle
Verschlüsselungsalgorithmen und was damit sonst noch zusammenhängt (Demos, Unit Tests...),
da EMBT lieber vorsichtig wegen amerikanischer Exportbeschränkungen agiert...

Dadurch wird diese Bibliothek aber immerhin unter GetIt sichtbar...
Und die IsPassword Methode hat noch eine vereinfachte Implementierung bekommen.
Die wandert nacher aber auch gleich in den Development Branch.

Grüße

TurboMagic

[DieDolly]

Was ist EMBT?
Heißt das also, DEC darf so nicht in den USA verwendet werden?

Bei DEC Lite fehlen alle Verschlüsselungsalgorithmen. Sollte das dann überhaupt noch "DEC" heißen?

[TurboMagic]

1. EMBT = Embarcadero Technologies.

2. Die wollen einfsch keine Bibliotheken in GetIt die starke Verschlüsselung umsetzen,
dam man sonst möglicherweise mit irgendwelchen US Exportregularien in Konflikt geraten
könnte und man evtl. 'ne Menge Papierkram auszufüllen hat.

3. Das sollte uns aber nicht tangieren und du darfst deine mit der DEC geschriebene Software
auch in die USA verbreiten. Andere tun's auch. Was anderes wäre es evtl. wenn du Kunden im
Iran oder so hättest und denen solche Verschlüsselungstechnologie verfügbar machst.
Da hätten die Amis was dagegen.

Jetzt alles klar? Meiner Meinung nach reine Vorsichtsmaßnahme von EMBT.

=> wenn du GetIt nicht benutzt, interessiert dich die Lite nicht und wenn du die volle Version
kennst und nutzt isntalliere halt, was dir GitHub zur Verfügung stellt. GetIt ist für diese
Bibliothek einfach eine Möglichkeit weitere Nutzer "anzufüttern" ok?

Grüße
TurboMagic

[Daniel]

Grundsätzlich sind das sehr gute Neuigkeiten, dass das DEC - wenn auch abgespeckt - in GetIt integriert wird.
Aber Details in Fragen dazu wären ein separates Thema wert.

[Aviator]

Zitat:

Zitat von TurboMagic (Beitrag 1482934)

Meine Frage wäre, was C# da an einfacher zu verwendende Methoden bietet?
In Punkto Kryptographie oder in Punkto String vs. Byte Arrays etc. und deren Umwandlung?

Naja es ist wohl eher eine subjektive Wahrnehmung. Man kann sich jetzt über die Syntax streiten. Teilweise kommen mir die Dinge eben einfacher vor was die Schreibweise und die Nutzung angeht. Es kann aber evtl. auch einfach daran liegen, dass die Codevervollständigung in VS deutlich besser ist als bei Delphi und man dadurch "leichter" ans Ziel kommt.

Meine Delphi Klasse habe ich analog meiner C# Klasse aufgebaut. Im Endeffekt erkennt man alles irgendwie wieder.

Code:

using System.IO;
using System.Linq;
using System.Security.Cryptography;
using WAC.Business.Interfaces;

namespace WAC.Business.Encryption
{
    public class AES : IAES
    {
        private readonly IAesKeyReader aesKeyReader;

        public AES(IAesKeyReader aesKeyReader)
        {
            this.aesKeyReader = aesKeyReader;
        }

        public byte[] Encrypt(string plainText)
        {
            using (AesManaged aes = new AesManaged())
            {
                return Encrypt(plainText, aes.IV);
            }
        }

        public string Decrypt(byte[] cipherText)
        {
            string plaintext = null;
            // Create AesManaged
            using (AesManaged aes = new AesManaged())
            {
                // Create the streams used for decryption.
                using (MemoryStream ms = new MemoryStream(cipherText))
                {
                    byte[] iv = new byte[16];
                    ms.Read(iv, 0, 16);

                    // Create a decryptor
                    ICryptoTransform decryptor = aes.CreateDecryptor(aesKeyReader.GetAesKey(), iv);

                    // Create crypto stream
                    using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                    {
                        // Read crypto stream
                        using (StreamReader reader = new StreamReader(cs))
                            plaintext = reader.ReadToEnd();
                    }
                }
            }

            return plaintext;
        }

        public byte[] Encrypt(string plainText, byte[] iv)
        {
            byte[] encrypted;
            // Create a new AesManaged.
            using (AesManaged aes = new AesManaged())
            {
                // Create encryptor
                ICryptoTransform encryptor = aes.CreateEncryptor(aesKeyReader.GetAesKey(), iv);
                // Create MemoryStream
                using (MemoryStream ms = new MemoryStream())
                {
                    // Create crypto stream using the CryptoStream class. This class is the key to encryption
                    // and encrypts and decrypts data from any given stream. In this case, we will pass a memory stream
                    // to encrypt
                    using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                    {
                        // Create StreamWriter and write data to a stream
                        using (StreamWriter sw = new StreamWriter(cs))
                            sw.Write(plainText);
                        encrypted = iv.Concat(ms.ToArray()).ToArray();
                    }
                }
            }
            // Return encrypted data
            return encrypted;
        }
    }
}