Probleme mit DCPcrypt

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