Probleme mit DCPcrypt

[DLX]

Hallo,

ich verwende DCPcrypt zum ver- und entschlüsseln von Text. Das klappt soweit auch Prima, jedoch hab ich das Problem das irgendwelche komischen Sonderzeichen beim entschlüsseln angehängt werden, habt ihr eine Lösung dafür ?

Code:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs,DCPcrypt2, DCPblockciphers, DCPrijndael, DCPbase64,
  Vcl.StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    Edit1: TEdit;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
function DecryptText():String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;

begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  Data := form1.Edit1.text;
  Data := DCPBase64.Base64DecodeStr(Data);
  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));

  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  form1.Memo1.Lines.Add(Data);


end;

function EncryptText():String;
var Cipher : TDCP_rijndael;
    Data,DataDec, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  //Data := 'thisis128bitstxt';
  Data := form1.edit1.text;

  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    //don't miss padding
    {start padding}
    dataLength := Length(Data);
    bsize := (Cipher.BlockSize div 8);
    pad := bsize - (dataLength mod bsize);
    for index := 1 to pad do
      Data := Data+chr(pad);
    {end padding}

    Cipher.EncryptCBC(Data[1],Data[1],Length(Data));

  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  Data := DCPBase64.Base64EncodeStr(Data);
  form1.Memo1.Lines.Add(Data);

end;

procedure TForm1.Button1Click(Sender: TObject);
begin
EncryptText();

end;
procedure TForm1.Button2Click(Sender: TObject);
begin
DecryptText();
end;

procedure TForm1.FormCreate(Sender: TObject);
begin

end;

end.

Ich hoffe Ihr habt eine Idee, Danke schonmal :-)

Grüße

[KodeZwerg]

DCPcrypt von welcher Quelle?
eingestelltes Original von David A.W. Barton
von Warren Postma
von Multiple User

[DLX]

DCPcrypt v2.0 written by David Barton

[gammatester]

Das werden die Padding-Bytes sein. Ich sehe sie beim Verschlüsseln aber nicht beim Entschlüsseln. Lösungen:

• Paddingbytes entfernen beim Entschlüsseln,
• Kein Padding und 'manuelles' Auffüllen auf 16-Byte-Vielfaches,
• Anderen Betriebsmodus nehmen (CFB8, CTR, OFB, CBC+Ciphertextstealing).

[DLX]

weiß jemand wie der code für das padding beim entschlüsseln wäre ?

[gammatester]

Zitat:

Zitat von DLX (Beitrag 1402893)

weiß jemand wie der code für das padding beim entschlüsseln wäre ?

Vermutlich ungefähr so in Pseudo-Code:

Code:

pad := ord(Data[length(Data)])
Entferne die letzten pad Bytes/Ansichars von Data

So wie ich den Source für's Verschlüsseln sehe, werden immer 1..16 Bytes angehängt.

[KodeZwerg]

Ersetze bei Dir

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Data);

mit

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Trim(Data));

und dann passt es.
In der DecryptText() funktion, falls das unklar ist.

ps: Ich habe die Sourceforge Variante genommen.
pps: Der Fehler ist das der Speicher überschrieben wird aber keine neue Länge bekommt.

[gammatester]

Zitat:

Zitat von KodeZwerg (Beitrag 1402914)

pps: Der Fehler ist das der Speicher überschrieben wird aber keine neue Länge bekommt.

Huh? Wo wird Speicher überschrieben?

Beim Verschlüsseln wird Data auf ein Vielfaches von 16 aufgefüllt (ohne Speicherüberschreibung).

Ich nehme ja wohl an, dass dieser verschlüsselte Text dann komplett wieder entschlüsselt wird. Da die Länge ein Vielfaches von 16 ist, kann er im CBC-Mode verarbeitet werden. Was übrigbleibt nach dem Entschlüsseln ist der Klartext+Padding, was noch entfernt werden muss.

Das Padding hängt n Bytes AnsiChar(n) an, wobei n = 16 - mod Klartextlänge ist. Mein Pseudocode macht das rückgängig.

Zitat:

Zitat von KodeZwerg (Beitrag 1402914)

Ersetze bei Dir

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Data);

mit

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Trim(Data));

und dann passt es.
In der DecryptText() funktion, falls das unklar ist.

Das wäre natürlich tödlich, da zB auch #9, #10, #13 entfernt würden. Der komplette Ciphertext ist relevant.

Edit: Sehe gerade das über Base64 gegangen wird, da sollte trim kein Problem sein, weil im Base64 keine relevanten Nicht-Ansidaten vorhanden sind. Aber das kann nicht das Problem sein, weil DCPBase64.Base64DecodeStr(Data) einen Fehler werfen müsste, falls ungültige Zeichen auftauchen.

[KodeZwerg]

Im Anhang ein dreckiges aber lauffähiges Beispiel.
Umgang:
Bei Erststart tippe da wo Edit1 steht etwas ein was Du verschlüsseln magst
Drücke Knopf Button1
In Memo erscheint der Base64 String kopiere ihn
Ersetze Edit1 mit dem String
Drücke Knopf Button2

Klappts?

[gammatester]

Wäre es nicht sinnvoller den Quellcode zu posten, als ein nacktes EXE?

[KodeZwerg]

Zitat:

Zitat von gammatester (Beitrag 1402917)

Wäre es nicht sinnvoller den Quellcode zu posten, als ein nacktes EXE?

Das tat ich.

Zitat:

Zitat von KodeZwerg (Beitrag 1402914)

Ersetze bei Dir

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Data);

mit

Delphi-Quellcode:

  form1.Memo1.Lines.Add(Trim(Data));

und dann passt es.
In der DecryptText() funktion, falls das unklar ist.

Der Rest vom Quelltext steht in Post #1 vom TE.

edit
Im Anhang der Source zum Sample

[gammatester]

Dein Sourcecode und wohl auch die Exe enthalten kein Entfernen des Paddings und ergeben deshalb Schrott. Mit dieser meiner Änderung funktionierts

Verschlüsseln
'Edit1' -> 'zwag7rEW4OWtTLpCHdbyoA=='

Entschlüsseln:
'zwag7rEW4OWtTLpCHdbyoA==' -> 'Edit1'

Delphi-Quellcode:

function DecryptText():String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
begin
  key := '12345678901234567890123456789012';
  IV := '1234567890123456';
  Data := DCPBase64.Base64DecodeStr(form1.Edit1.text);
  Cipher := TDCP_rijndael.Create(NIL);
  try
    Cipher.Init(Key[1],128,@IV[1]);
    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
    pad := 16- ord(Data[length(Data)]);
    for index :=1 to pad do delete(Data,length(Data),1);
  finally
    Cipher.Burn;
    Cipher.Free;
  end;
  form1.Memo1.Lines.Add(Data);
end;

[KodeZwerg]

Zitat:

Zitat von gammatester (Beitrag 1402920)

Dein Sourcecode und wohl auch die Exe enthalten kein Entfernen des Paddings und ergeben deshalb Schrott.

?
Wenn man natürlich stur seinen Willen haben möchte ohne überhaupt mal das andere ausprobiert zu haben.
Nutze mein .exe oder .dpr und bau eigenes .exe
Bedien es wie ich schrieb
Was soll bitteschön Schrott sein?
Hättest Du geschrieben das meine Methode Schrott ist weil sie führende oder abschließende Leerzeichen entfernt, da hät ich Dir Recht gegeben aber Grundlos so etwas zu Schreiben. Ich bin raus.

edit
und das beste, ohne Trim funktioniert dein Source null. Tolle Leistung. Aber mein Source = Schrott.

[gammatester]

Sorry, falls der Ton etwas rauh war.

Aber Dein Programm funktioniert, nur wenn der Text keine Ansizeichen <= 32 am Ende hat. Das ist vielleicht für das Ver/Entschlüsseln von Edit-Felder OK, aber nicht für allgemeine Daten. Aber selbst führende Leerzeichen werden weggetrimmt.

Versuche einmal ' a b c ' mit Deiner Version zu verarbeiten. Mit dem trim gibt das Entschlüsseln 'a b c', und wenn man das trim entfernt: ' a b c ???????' (im Original: Krakel statt ?)

Der Ciphertext ist für beide Versionen 'YEasidM6jJlOuYsjSFIliA=='

Allerdings muss ich sagen, das es für solche eingeschränkten Daten (also ohne führende und angehängte Leer- und Steuerzeichen) in der Tat zu funktioieren scheint, weil die Padding-Bytes <= #16 sind, die beim trim dann entfernt werden.

Und mein Program funktioniert auch nur, wenn das trim entfernt wird (aber das war schon vorhanden, ich wollte nur das De-Padding einbauen, habe das trim jetzt im Code entfernt). Ich verstehe nicht, wieso es mein Code bei Dir nicht funktioniert, wenn das Trim entfernt wird.

Gute Nacht
Gammatester

[KodeZwerg]

Ok gammatester, nur für Dich um Dir zu zeigen was da so passiert bei mir mit Deiner Änderung in Deiner letzten Variante.
Ich habe nun zwei Checkboxen drinn, GUI mini aufgewertet.
Checkbox1 ist dein Padding, On/Off.
Checkbox2 ist mein Trim, On/Off.
GUI ist diesmal beschriftet.

Delphi-Quellcode:

function DecryptText():String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;

begin
  key := '12345678901234567890123456789012';
  IV := '1234567890123456';
  Data := form1.Edit1.text;
  Data := DCPBase64.Base64DecodeStr(Data);
  Cipher := TDCP_rijndael.Create(NIL);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));

    if form1.CheckBox1.Checked then
    begin
      pad := 16- ord(Data[length(Data)]);
      for index :=1 to pad do delete(Data,length(Data),1);
    end;

  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  if form1.CheckBox2.Checked then
   form1.Memo1.Lines.Add(Trim(Data))
   else form1.Memo1.Lines.Add(Data);
  if form1.CheckBox2.Checked then
   form1.Edit1.Text := Trim(Data)
   else form1.Edit1.Text := Data;

end;

Im Anhang kompilat plus Source.
Sobald ich "mein" häckchen entferne, rate was passiert, das was der TE weg haben wollte erscheint wieder.

[gammatester]

Moin,
ich konnte das Problem mit dem De-Padding reproduzieren. Ich habe in der Hektik meinen eigenen Pseudo-Code falsch umgesetzt :wall:. Mit dieser Änderung Deines Codes sollte es OK sein

Delphi-Quellcode:

    if form1.CheckBox1.Checked then
    begin
      pad := ord(Data[length(Data)]);
      for index :=1 to pad do delete(Data,length(Data),1);
    end;

Natürlich ist das trotzdem noch eine Schnell-Lösung. Ein robuster Code sollte auch noch checken, ob der eingegebene Text für die Entschlüsselung gültiges Base64 ist, ob die Ciphertext-Länge ein Vielfaches von 16 ist, etc.

[himitsu]

Delphi-Quellcode:

for index :=1 to pad do delete(Data,length(Data),1);

wer sieht auch sofort, dass der Herr Mathematik das FOR sofort und mit nur einem Handgriff entfernen kann?


PS: StringOfChar für die andere Richtung.

[KodeZwerg]

Zitat:

Zitat von gammatester (Beitrag 1402940)

Mit dieser Änderung Deines Codes sollte es OK sein

Klappt diesmal!

Zitat:

Zitat von himitsu (Beitrag 1402942)

wer sieht auch sofort

Ich :lol:

Delphi-Quellcode:

      Delete(Data, Length(Data) +1 -pad, pad);
//oder
      SetLength(Data, Length(Data) -pad);
//oder
      Data := Copy(Data, 1, Length(Data) -pad);

Ich glaube SetLength() ist die schnellste von diesen Möglichkeiten. Ich nutze es jedenfalls.

[DLX]

Ich danke euch sehr für eure Hilfe! Klasse... echt !
Eine kurze Frage hab ich noch, kann ich auch Buchstaben als Key wählen ? Und muss dieser immer 32 zeichen lang sein ?

[KodeZwerg]

Delphi-Quellcode:

key := 'Super Geheim';
IV := 'DLX';

Es sind AnsiStrings, trag da ein was auch immer Du magst.

Ps:
Alternativ kannst Du es auch so machen:

Delphi-Quellcode:

function DecryptText(const Key, IV: AnsiString):String;

Und Du rufst die Funktion mit entsprechenden Parameter auf.
Also so:

Delphi-Quellcode:

function DecryptText(const Key, IV: AnsiString):String;
var Cipher : TDCP_rijndael;
    Data : ansistring;
    //Key, IV : ansistring; // <- Das hier rauswerfen
    index, dataLength, bsize, pad: integer;
begin
//  key := '12345678901234567890123456789012'; // <- Das hier rauswerfen
//  IV := '1234567890123456'; // <- Das hier rauswerfen

[DLX]

Ich hab die beiden funktionen nun so gemacht:

Code:

function DecryptText(input:string):String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;

begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  Data := input;
  Data := DCPBase64.Base64DecodeStr(Data);
  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
          pad := 16- ord(Data[length(Data)]);
      for index :=1 to pad do delete(Data,length(Data),1);
  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  Result:=trim(Data);


end;

function EncryptText(input:string):String;
var Cipher : TDCP_rijndael;
    Data,DataDec, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  //Data := 'thisis128bitstxt';
  Data := input;

  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    //don't miss padding
    {start padding}
    dataLength := Length(Data);
    bsize := (Cipher.BlockSize div 8);
    pad := bsize - (dataLength mod bsize);
    for index := 1 to pad do
      Data := Data+chr(pad);
    {end padding}

    Cipher.EncryptCBC(Data[1],Data[1],Length(Data));

  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  Data := DCPBase64.Base64EncodeStr(Data);
 Result:=Data;

end;

Text: Heute sitze ich hier und teste es sehr doll
Crypted:1r4gz8+TFpWBvykCVx9YJp5fVQKx2z3XidDLsq5S0W ZeEiUmXoqgLe5wVDklJ4kU

wenn ich das dann wieder entschlüssel
Crypted: 1r4gz8+TFpWBvykCVx9YJp5fVQKx2z3XidDLsq5S0WZeEiUmXo qgLe5wVDklJ4kU
Text: Heute sitze ich hier und teste es seh

Es fehlt also was, was mach ich falsch ?

[KodeZwerg]

Du benutzt noch Trim, wir haben doch aktualisierte Codes geposted.

[gammatester]

Zitat:

Zitat von KodeZwerg (Beitrag 1403153)

Delphi-Quellcode:

key := 'Super Geheim';
IV := 'DLX';

Es sind AnsiStrings, trag da ein was auch immer Du magst.

Ps:
Alternativ kannst Du es auch so machen:

Delphi-Quellcode:

function DecryptText(const Key, IV: AnsiString):String;

Und Du rufst die Funktion mit entsprechenden Parameter auf.

Allerdings muß man sich im klaren sein, daß dann der Algorithmus von der Stringlänge abhängt. Für Längen <=16 wird AES-128 verwendet, für Längen <= 24 dann AES-192 und sonst AES-256. Selbstverständlich darf dann auch nicht mit

Delphi-Quellcode:

Cipher.Init(Key[1],128,@IV[1]);

ohne Crash-Gefahr initilisiert werden. Ein IV muss 16 Bytes sein, da init einen Pointer verlangt, müssen mindestes 16 Bytes vorhanden. Ein IV := 'DLX' könnte dann crashen.

Zitat:

Zitat von DLX (Beitrag 1403158)

Ich hab die beiden funktionen nun so gemacht:
...

Delphi-Quellcode:

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
          pad := 16- ord(Data[length(Data)]);
      for index :=1 to pad do delete(Data,length(Data),1);

Außer dem trim wie von Kodezwerg bemerkt, ändere das ab zu

Delphi-Quellcode:

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
    pad := ord(Data[length(Data)]);
    for index :=1 to pad do delete(Data,length(Data),1);

Der vorliegende Code verwendet also keinen 256-Bit-Schüssel sonder 'nur' 128 Bit.

[DLX]

Vielen Dank, also bin ich von der zu verschlüsselten Stringlänge begrenzt ?

[gammatester]

s.u.

[KodeZwerg]

Im Anhang ist das Projekt, nun für alles Edit-Felder vorhanden. Viel Spass damit.

Hier der Code:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls,
  DCPcrypt2, DCPblockciphers, DCPrijndael, DCPbase64;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Memo1: TMemo;
    eText: TEdit;
    CheckBox1: TCheckBox;
    CheckBox2: TCheckBox;
    eKey: TEdit;
    eMKey: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function DecryptText( Data, Key, MasterKey: AnsiString ):String;
var Cipher : TDCP_rijndael;
    index, dataLength, bsize, pad: integer;
begin
  Data := DCPBase64.Base64DecodeStr(Data);
  Cipher := TDCP_rijndael.Create(NIL);
  try
    Cipher.Init(Key[1],128,@MasterKey[1]);
    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
    if form1.CheckBox1.Checked then
    begin
      pad := ord(Data[length(Data)]);
      SetLength(Data, length(Data)-pad);
    end;
  finally
    Cipher.Burn;
    Cipher.Free;
  end;
  if form1.CheckBox2.Checked then
   form1.Memo1.Lines.Add(Trim(Data))
   else form1.Memo1.Lines.Add(Data);
  if form1.CheckBox2.Checked then
   form1.eText.Text := Trim(Data)
   else form1.eText.Text := Data;
end;

function EncryptText( Data, Key, MasterKey: AnsiString ):String;
var Cipher : TDCP_rijndael;
    {Data,}DataDec{, Key, IV }: ansistring;
    index, dataLength, bsize, pad: integer;
begin
  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@MasterKey[1]);
    dataLength := Length(Data);
    bsize := (Cipher.BlockSize div 8);
    pad := bsize - (dataLength mod bsize);
    for index := 1 to pad do
      Data := Data+chr(pad);
    Cipher.EncryptCBC(Data[1],Data[1],Length(Data));
  finally
    Cipher.Burn;
    Cipher.Free;
  end;
  Data := DCPBase64.Base64EncodeStr(Data);
  form1.Memo1.Lines.Add(Data);
  form1.eText.Text := Data;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  EncryptText(eText.Text, eKey.Text, eMKey.Text);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  DecryptText(eText.Text, eKey.Text, eMKey.Text);
end;

end.

Und wie bereits erwähnt wurde, das ist momentan nur für Text geeignet. Anhang 49146

[gammatester]

Zitat:

Zitat von DLX (Beitrag 1403164)

und mit Trim ?! oder seh ich da was falsch?

Das war ja nur zu Demo-Zwecken. Das De-Padding ist noch fehlerhaft, ändere es wie ich es beschrieben habe. Da Du wahrscheinlich keine Kontrollzeichen am Anfang/Ende Deines Textes verwendest, ist das trim nur sekundär problematisch.

Edit: Die Länge der zu ver/entschüsselnden Texte ist auf 2GB beschränkt (bzw etwas weniger wg. der Base64-Kodierung). Die Schlüssellänge ist nur bis 32 Zeichen signifikant.

[KodeZwerg]

Ohh ja, ist mir noch gar nicht aufgefallen, hier eine mini Sicherheits Prüfung

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if length(eKey.Text) < 8 then form1.Memo1.Lines.Add('Schlüssel muss mindestens 8 Zeichen lang sein!')
  else
  EncryptText(eText.Text, eKey.Text, eMKey.Text);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  if length(eKey.Text) < 8 then form1.Memo1.Lines.Add('Schlüssel muss mindestens 8 Zeichen lang sein!')
  else
  DecryptText(eText.Text, eKey.Text, eMKey.Text);
end;

[DLX]

So funktioniert es nun

Code:

function DecryptText(input:string):String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;

begin
  //key := '12345678901234567890123456789012';
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  Data := input;
  Data := DCPBase64.Base64DecodeStr(Data);
  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    Cipher.DecryptCBC(Data[1],Data[1],Length(Data));
    pad := ord(Data[length(Data)]);
    for index :=1 to pad do delete(Data,length(Data),1);
  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  Result:=Data;


end;

function EncryptText(input:string):String;
var Cipher : TDCP_rijndael;
    Data,DataDec, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';
  Data := input;

  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);

    //don't miss padding
    {start padding}
    dataLength := Length(Data);
    bsize := (Cipher.BlockSize div 8);
    pad := bsize - (dataLength mod bsize);
    for index := 1 to pad do
      Data := Data+chr(pad);
    {end padding}

    Cipher.EncryptCBC(Data[1],Data[1],Length(Data));

  finally
    Cipher.Burn;
    Cipher.Free;
  end;

  Data := DCPBase64.Base64EncodeStr(Data);
 Result:=Data;

end;

Um also einen Schlüssel länger als 32 Zeichen zu nehmen müsste ich dann auf 256bits umstellen bei dem Cipher.init ?

[gammatester]

Zitat:

Zitat von DLX (Beitrag 1403173)

Um also einen Schlüssel länger als 32 Zeichen zu nehmen müsste ich dann auf 256bits umstellen bei dem Cipher.init ?

Nein, die maximale Schüssellänge ist 32 Bytes/Zeichen = 256 Bit.

Wenn Du mehr Zeichen verwenden willst, benutze eine Hash- oder KDF-Funktion (Schlüsselableitungsfunktion) mit 256-Bit und nimm den Hash als Schüssel, Stichwort Passwort-Hashing.

[DLX]

alles klar, vielen Dank!!!

[KodeZwerg]

Zitat:

Zitat von gammatester (Beitrag 1403163)

Ein IV := 'DLX' könnte dann crashen.

Nee, aber ein Key := 'DLX', da braucht man die 16bytes. IV kann auch '' sein.

[gammatester]

Zitat:

Zitat von KodeZwerg (Beitrag 1403184)

Zitat:

Zitat von gammatester (Beitrag 1403163)

Ein IV := 'DLX' könnte dann crashen.

Nee, aber ein Key := 'DLX', da braucht man die 16bytes. IV kann auch '' sein.

Sehe ich anders:
Bezüglich Schlüssel:

Delphi-Quellcode:

procedure TDCP_rijndael.InitKey(const Key; Size: longword);
var
  KC, ROUNDS, j, r, t, rconpointer: longword;
  tk: array[0..MAXKC-1,0..3] of byte;
begin
  Size:= Size div 8;

  FillChar(tk,Sizeof(tk),0);
  Move(Key,tk,Size);
  if Size<= 16 then
  begin
    KC:= 4;
    Rounds:= 10;
  end
  else if Size<= 24 then
  begin
    KC:= 6;
    Rounds:= 12;
  end
  else
  begin
    KC:= 8;
    Rounds:= 14;
  end;

und bei den IVs

Delphi-Quellcode:

procedure TDCP_blockcipher128.SetIV(const Value);
begin
  if not fInitialized then
    raise EDCP_blockcipher.Create('Cipher not initialized');
  Move(Value,IV,16);
  Reset;
end;

bzw

Delphi-Quellcode:

procedure TDCP_blockcipher128.Init(const Key; Size: longword; InitVector: pointer);
begin
  inherited Init(Key,Size,InitVector);
  InitKey(Key,Size);
  if InitVector= nil then
  begin
    FillChar(IV,16,{$IFDEF DCP1COMPAT}$FF{$ELSE}0{$ENDIF});
    EncryptECB(IV,IV);
    Reset;
  end
  else
  begin
    Move(InitVector^,IV,16);
    Reset;
  end;
end;

Du kannst also einen nil-pointer übergeben, es werden dann 16 Bytes 0 verwendet (DLX := '' ist wie nil-pointer), aber ansonsten werden mit dem move immer 16 Bytes benötigt. (Es muß aber nicht zum Crash kommen, je nach Speicherlage). Wenn's nicht crasht können durch Zufallsbelegungen unterschiedlich IVs entstehen, und das Ergebnis ist fehlerhaft.

Debugger für IV := '1';

Encrypt-IV: ( 49, 0, 0, 0, 50, 0, 0, 0, 1, 0, 0, 0, 32, 0, 0, 0)
Decrypt-IV: ( 49, 0, 0, 0, 4, 22, 70, 0, 216, 31, 186, 1, 224, 50, 0, 0)

Die 49 entsprechen '1' der Rest ist mehr oder weniger Zufall.

[KodeZwerg]

Ich habe mal ein wenig probiert, stimmt schon mit den initvector, der sollte schon eine fixe 16byte länge haben sonst ist das Ergebnis nicht unbedingt überall gleich.
Am besten wäre vielleicht für den TE sich auf bestehendes zu verlassen, es gibt ja wolfgang-ehrhardt und da finden sich zu vielen AES Verfahren super Lösungen an der nicht mehr rumgefummelt werden muss damit es klappt.
DelphiEncryptionCompendium (DEC) gibt es ja auch noch, nur liegt das Projekt schon ewig brach.

[KodeZwerg]

Ich war mal fleißig und habe das FileEncryption Demo umgeschrieben das es mit Strings arbeitet.
Nicht Wundern, beim Generieren von verschlüsselten Text bekommst Du jedes mal ein anderes Ergebis, was beim Entschlüsseln wieder korrekt in den Ausgangs-String umgewandelt wird.
Es sollten alle Ciphers und Hashs enthalten und Unterstützt sein.
Ich habe es noch nicht bis ins kleinste Detail getestet, aber mein Erst-Eindruck = es funktioniert tadellos.

So sieht die GUI aus. Anhang 49148
Im Anhang ist kompletter Source plus ein Kompilat zum sofort testen.

Anwendung:
1. In oberster Zeile kommt Dein Text zum verschlüsseln rein, ganz unten bei "passphrase" gehört Dein Wunsch-Passwort rein, darunter nochmal zur Bestätigung.
2. Drück "Encrypt" und das Ergebnis ist nun in zweiter Zeile
3. Drück "Decrypt" und in oberster Zeile steht der entschlüsselte Text wieder lesbar.
4. Drück "Close" zum ....

Viel Spass damit!

[KodeZwerg]

Finaler Nachtrag
Während vieler Denkpausen bei einem anderen Projekt habe ich immer mal wieder mit dem obigen Programm herumgespielt.
Ich muss feststellen, es ist bombensicher, ich habe keine Möglichkeit entdecken können wie man es knacken kann.
Solange man "in Echtzeit" Passwörter eintippen muss arbeitet dieses Verschlüsselungsverfahren absolut spitze da es nie den gleichen "Crypted Text" generiert. Ich bin total begeistert und wollte mich abschließend nochmal für diesen Thread bedanken durch den ich den Umgang lernte aus TFileStream Speicherstreams zu machen und aus input und output Strings zu generieren.

[DLX]

in erster Linie bedanke ich mich für die großartige Hilfe ! :-)
Was müsste ich eigentlich machen wenn ich auch Dateien ver- und entschlüsseln wollen würde ?

hab es jetzt wie folt gelöst:

Code:

function encryptFile(inputFile:string; outputFile:string):String;
var Cipher : TDCP_rijndael;
    Data,DataDec, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
    Source, Dest: TFileStream;
begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';

  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);
    Source:= TFileStream.Create(inputFile,fmOpenRead);
    Dest:= TFileStream.Create(outputFile,fmCreate);
    Cipher.EncryptStream(Source,Dest,Source.Size);


  finally
    Cipher.Burn;
    Cipher.Free;
    source.Free;
    dest.Free;
  end;

 Result:='fertig';

end;

und zum entschlüsseln:

Code:

function DecryptFile(inputFile:string; outputFile:string):String;
var Cipher : TDCP_rijndael;
    Data, Key, IV : ansistring;
    index, dataLength, bsize, pad: integer;
    Source, Dest: TFileStream;

begin
  key := '12345678901234567890123456789012';
  IV  := '1234567890123456';

  Cipher := TDCP_rijndael.Create(nil);
  try
    Cipher.Init(Key[1],128,@IV[1]);
    Source:= TFileStream.Create(inputFile,fmOpenRead);
    Dest:= TFileStream.Create(outputFile,fmCreate);
    Cipher.DecryptStream(Source,Dest,Source.Size);
  finally
    Cipher.Burn;
    Cipher.Free;
    Dest.Free;
    Source.Free;
  end;

  Result:='fertig';


end;

[KodeZwerg]

Hier ist das FileEncrypt Demo was ich ober für Dich umgeschrieben hatte, damit sollte nun alles nur erdenkliche Abgedeckt sein. Falls Du da etwas nicht verstehen solltest, frage ruhig nach.

Ps: Ich gehe absichtlich nicht auf Deinen Code ein da er irgendwie falsch ist.

edit
Sorry, ich hatte die Archive verwechselt und das StringEncrypt fälschlicher Weise hochgeladen, hier nun das korrekte!

[DLX]

bekomme wenn ich deine Demo öffne den Fehler : no ciphers where found, hab aber alle dateien soweit eingebunden

[KodeZwerg]

Hier ist das komplette Package mit Demos und Source und allem drum und dran so wie ich es in Benutzung habe.
Ich schrieb ja relativ am Anfang das es verschiedene Versionen gibt.
Falls es unangebracht ist dieses Package hier fest zu verlinken, bitte löschen.
Mit dem obigen StringEncrypt ist es komplett so wie bei mir.
(nach Integration in IDE muss der Source Ordner der IDE Library-Path hinzugefügt werden oder den Inhalt in ein Ordner der im Library-Path rein kopieren)
Viel Spass dabei!