Rijndael-Entschlüsselung

[ArneH]

Hallo!

Ich möchte in meiner Delphi/FreePascal-Anwendung Strings entschlüsseln, die mit Rijndael im CFB-Modus verschlüsselt sind.

Mit Python funktioniert das auch wunderbar, nur unter Delphi kriege ich es nicht hin.

Prinzipiell sollte das so laufen:

Code:

key = binascii.unhexlify('A3A882F4860F09E8F8B526BA15A161951EF7A00F00000000')

iv = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
iv_cipher = AES.new(key,AES.MODE_ECB)
iv = iv_cipher.encrypt(iv)
   
cipher = AES.new(key,AES.MODE_CFB,iv)
   
result = cipher.decrypt(encryptedstring)

Ich habe nun schon verschiedene Komponenten in Delphi ausprobiert (DEC, TLockBox, DCPcrypt), aber ich habe es nicht hingekriegt.

Könnte mir da bitte jemand auf die Sprünge helfen? Ich bin nach mehreren Stunden des vergeblichen Versuchens nämlich so langsam am Verzweifeln...

[gammatester]

Zitat:

Zitat von ArneH

Hallo!

Rijndael im CFB-Modus

Code:

key = binascii.unhexlify('A3A882F4860F09E8F8B526BA15A161951EF7A00F00000000')

iv = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
iv_cipher = AES.new(key,AES.MODE_ECB)
iv = iv_cipher.encrypt(iv)
   
cipher = AES.new(key,AES.MODE_CFB,iv)
   
result = cipher.decrypt(encryptedstring)

Das ist auf jeden Fall kein Standard-CFB, da der IV zuerst im ECB-Modus verschlüsselt wird. Bis Du sicher, daß nicht der unverschlüsselte IV im

Delphi-Quellcode:

cipher = AES.new(key,AES.MODE_CFB,iv)

stehen muss?

Außerdem wäre zu klären, ob es ein 8-Bit-, 64-Bit- oder 128-Bit-CFB ist?

Lauft Dein Code mit den offiziellen Testvektoren aus der NIST-Spec?
http://csrc.nist.gov/publications/ni...SP_800-38B.pdf

Wenn die beiden Sachen klar sind, sollte es kein Problem sein, den Code nach Pascal zu übersetzen (wenn die Library den 8,64 oder 128 Bitmodus unterstützt, meine zB hat nur den 128-er).

Gruß Gammatester

[q3fuba]

hi, gammatester

ich habe das das selbe problem wie ArneH.

Der IV (was auch immer das ist) wird bei mir auch ZUERST im ECB Verschlüsselt und dann wird IV_Cipher encrypted.

also so:

Delphi-Quellcode:

IV = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
IV_Cipher = AES.new(Key,AES.MODE_ECB)
IV = IV_Cipher.encrypt(IV)

nur beu mir geht das ganz dann sogar noch weiter ^_^

Delphi-Quellcode:

Key = binascii.unhexlify('F1C500DA3292182CF80CC3732239EEB3F560EAA100000000')

IV = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
IV_Cipher = AES.new(Key,AES.MODE_ECB)
IV = IV_Cipher.encrypt(IV)

obj = AES.new(Key,AES.MODE_CFB,IV)

afile = open(infile,'r')

data = afile.read()
data = binascii.unhexlify(''.join(data.split()))
data = data.splitlines()

habs auch mit LockBox rumgespielt, aber nichts rausbekommen.

Ob der key 128, 192 oder 256 (welche ich bei LockBox auswählen kann) ist, ist eigentlich egal, das kann man ja testen.

mich würde eben auch nur der Pascal code von meinem Python code interessieren :)

danke schonmal im voraus für eure hilfe!

[ArneH]

@q3fuba: Da will wohl jemand RSD-Files entschlüsseln... :)

[gammatester]

Hallo Leute.

ich weiß zwar nicht, was die genauen Probleme sind. Aber ich bin sehr sicher, da0 sie nicht mit Lockbox zu lösen sind.

Vergeßt Lockbox! Zu langsam, veraltet, nicht Standard und vor allem: Man hat keine Möglichkeit den IV selbst vorzugeben:

Delphi-Quellcode:

  if Encrypt then begin
    {set up an initialization vector (IV)}
{$IFDEF MSWINDOWS}
    Block[0] := timeGetTime;
    Block[1] := timeGetTime;
{$ENDIF}
{$IFDEF LINUX}
    fd := fopen( '/dev/random', 'r' );
    fread( @Block[0], SizeOf( byte ), SizeOf( Block[0] ), fd );
    fread( @Block[1], SizeOf( byte ), SizeOf( Block[1] ), fd );
    fclose( fd );
{$ENDIF}

Wenn bekannt ist, was verwendet wird und wie, sollte es doch möglich sein, systematisch eine Lösung zu finden mit verlässlichen Paketen, neben dem hier allseits bekannten DEC kann man noch Dave Bartons http://www.cityinthesky.co.uk/cryptography.html oder meine Routinen von http://home.netsurf.de/wolfgang.ehrhardt/crypt_de.html verwenden.

Gruß Gammatester

[q3fuba]

Zitat:

@q3fuba: Da will wohl jemand RSD-Files entschlüsseln... :)

nöö *zwinker*
Würde mich allgemein mal gerne mit Crypting usw beschäftigen, da es ja nützlich ist ^_^

Zitat:

Zitat von gammatester

Hallo Leute.

ich weiß zwar nicht, was die genauen Probleme sind. Aber ich bin sehr sicher, da0 sie nicht mit Lockbox zu lösen sind.

Vergeßt Lockbox! Zu langsam, veraltet, nicht Standard und vor allem: Man hat keine Möglichkeit den IV selbst vorzugeben:

Delphi-Quellcode:

  if Encrypt then begin
    {set up an initialization vector (IV)}
{$IFDEF MSWINDOWS}
    Block[0] := timeGetTime;
    Block[1] := timeGetTime;
{$ENDIF}
{$IFDEF LINUX}
    fd := fopen( '/dev/random', 'r' );
    fread( @Block[0], SizeOf( byte ), SizeOf( Block[0] ), fd );
    fread( @Block[1], SizeOf( byte ), SizeOf( Block[1] ), fd );
    fclose( fd );
{$ENDIF}

Wenn bekannt ist, was verwendet wird und wie, sollte es doch möglich sein, systematisch eine Lösung zu finden mit verlässlichen Paketen, neben dem hier allseits bekannten DEC kann man noch Dave Bartons http://www.cityinthesky.co.uk/cryptography.html oder meine Routinen von http://home.netsurf.de/wolfgang.ehrhardt/crypt_de.html verwenden.

Gruß Gammatester

Hmm jo hab jetzt mal DCPCrypt installed.
"Rijndael" ist ja das neue AES soweit ich gelesen habe, wobei ich sagen muss,
ich habe bis jetzt nur mit XOR Cryption beschäftigt und das nicht wirklich intensiv.

Also habe mit Crypting eher wenig erfahung :!:

Wenn ich jetzt die componente "DCP_rijndael" ins form stecke, kann ich ja die Crypting Mode auswählen...
Aber da gibts keine "ECB" Mode zur auswahl, bei LockBox konnte man das auswählen.

Hier habe ich nur folgende:
cmCBC
cmCFB8bit
cmCFBblock
cmCTR
cmOFB

Da sehe ich also schonmal die erste Türe die für mich verschlossen ist :?

bis jetzt habe ich es soweit (ist aber warscheinlich auch falsch)

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  key, Text: string;
begin
  Text:='mein Text';
  key:='8C35192D964DC3182C6F84F3252239EB4A320D2500000000';
  DCP_rijndael1.SetIV('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');

  // Hier fehlt noch einiges, was ich nicht verstehe wie es gemacht wird

  Memo1.Lines.Text:=DCP_rijndael1.DecryptString(Text);
end;

währe dir dankbar wenn du mir dabei auf die sprünge helfen könntest oder vielleicht irgendwo ein tutorial wie man AES IV mit Delphi verwendet wenn möglich für DCPCrypt.

Weil ich wiss das ganze dann ja auch verstehen können, warum das so oder so gemacht wird.

[gammatester]

Zitat:

Zitat von q3fuba

währe dir dankbar wenn du mir dabei auf die sprünge helfen könntest oder vielleicht irgendwo ein tutorial wie man AES IV mit Delphi verwendet wenn möglich für DCPCrypt.

Fluch und Segen von Komponenten! Hinweis: Nach Installation die Datei BlockCiphers.html im Verzeichnis doc ansehen,

Zitat:

The TDCP_blockcipher component extends the TDCP_cipher component to provide chaining mode functions. Functions available are:
...

Delphi-Quellcode:

 
procedure EncryptECB(const Indata; var Outdata);
procedure DecryptECB(const Indata; var Outdata);

Darüber hinaus kannst Du ja wohl nicht erwarten, daß ich ein Tutorial für fremde Bibliotheken schreibe, (wenn dann erstmal für die eigene).

Für erste gute Hinweise sind die Artikel von wikipedia zu empfehlen, zB http://de.wikipedia.org/wiki/Cipher_Block_Chaining_Mode

Gruß Gammatester

[negaH]

Poste doch mal das was nach der Ent-Verscxhlüsselung als Resultat rauskommen soll.

Im DEC machst du das so

Delphi-Quellcode:

with TCipher_Rijndael.Create do
try
  Mode := cmCFB8; // CFB-8Bit Feedback
  Init(TFormat_HEX.Decode('8C35192D964DC3182C6F84F3252239EB4A320D2500000000'), '', $FF); // IV ist $FF befüllt
  Result := DecodeBinary('0102030AAFFCC', TFormat_HEX); // Result ist lesbar, Input ist HEX Formatiert
finally
  Free;
end;

Also, am besten du postest hier zwei Sets von Passwörtern + Verschlüsselten Daten + Entschlüsselten Daten, alles im HEX Format. Dann bin ich wsentlich schneller beim Austesten aller möglichen Parameter als zu verstehen was du exakt möchtest, was du schon probiert hast und ob deine Angaben auch stimmen und nicht Missverständnisse sind.

Gruß Hagen

[q3fuba]

Zitat:

Also, am besten du postest hier zwei Sets von Passwörtern + Verschlüsselten Daten + Entschlüsselten Daten, alles im HEX Format. Dann bin ich wsentlich schneller beim Austesten aller möglichen Parameter als zu verstehen was du exakt möchtest, was du schon probiert hast und ob deine Angaben auch stimmen und nicht Missverständnisse sind.

So hier hab ich mal 3 varianten von Ver/Entschlüsselten strings:

Code:

Verschlüsselt 1:
696D6C5666374861645137307A6C466C516E6F2F73736937614A616C734E4C765830636751345930544E
5432334C4C6752306256646C652F77735A3246704B6E5A654F6C6E686E2F586E4C4C4A6E3D3D0D0A^

Entschlüsselt 1:
CCF: [url]http://rapidshare.com/files/58141435/voy402.part1.rar[/url]

------------------------------------------------------------------------------

Verschlüsselt 2:
696D6C5666374861645137307A6C466C516E6F2F73736937614A616C734E4C765830636751345930544E
5432304434714341456B506573524D424B4930497A7A57357A3D0D0A

Entschlüsselt 2:
CCF: [url]http://rapidshare.com/files/91891665/D2SC.rar[/url]

------------------------------------------------------------------------------

Verschlüsselt 3:
696D6C5666374861645137307A6C466C516E6F2F73736937614A616C734E4C765830636751345930544E
5432304434714341456B506573524D424B4930497A7A57357A3D0D0A387447614C6C6B4F365264314831
4558386B414F55664B47494E486E4F346C6F376C4A31777233516E7867315234455571724D3752596F2F
324F3335376B2B2F5A7639304E715976425456390D0A

Entschlüsselt 3:
CCF: [url]http://rapidshare.com/files/91891665/D2SC.rar[/url]
CCF: [url]http://rapidshare.com/files/72806508/Forum_Tools.rar[/url]

Das "Passwort" ist immer gleich, bei allen und wie schon oben geschrieben:

Code:

8C35192D964DC3182C6F84F3252239EB4A320D2500000000

der komplette inhalt der "decrypt.py" ist der hier:

Code:

#!/usr/bin/env python

import binascii
import base64 
from Crypto.Cipher import AES
import sys

# 8C 35 19 2D 96 4D C3 18 2C 6F 84 F3 25 22 39 EB 4A 32 0D 25

infile = sys.argv[1]
outfile = infile+'.txt'
Key = binascii.unhexlify('8C35192D964DC3182C6F84F3252239EB4A320D2500000000')

IV = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
IV_Cipher = AES.new(Key,AES.MODE_ECB)
IV = IV_Cipher.encrypt(IV)

obj = AES.new(Key,AES.MODE_CFB,IV)

afile = open(infile,'r')
f = open(outfile, 'w')

data = afile.read()
data = binascii.unhexlify(''.join(data.split()))
data = data.splitlines()

for link in data:
    link = base64.b64decode(link)
    link = obj.decrypt(link)
    f.write(str(link.replace('CCF: ', ''))+'\n')   

afile.close()
f.close()

hab den schon so modifiziert, dass das ergebnis fast so ist, wie ich es haben will, nur will ich das ganze jetzt auch in delphi machen können.

Hoffe das hilft dir, folgedessen auch mir weiter :)

// edit sorry wegen der DEC, hab nicht gewusst dass die von dir is :oops:
// auch "installiert hab ichs jetzt schon, also die ordner einfach in den suchpfad hinzugefügt und schon funzt der code auch -> :wall:

[edit=Jelly]Zeilen umgebrochen... Mfg, Jelly[/edit]

[BUG]

Zitat:

Zitat von q3fuba

wieso ich die DEC von Luckie nicht installen kann :)

Da bist gut, die DEC ( <- siehe Hint) ist von Hagen aka negaH :mrgreen:

OnTopic: Hast du schon nach DEC AND installieren gesucht?

MfG,
Bug

[negaH]

ok,

IV = binascii.unhexlify('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FF')
IV_Cipher = AES.new(Key,AES.MODE_ECB)
IV = IV_Cipher.encrypt(IV)

zeige mal zu deinen Testvektoren noch den IV nach IV_Cipher.Encrypt() als HEX String. Bisher konnte ich nichts reproduzieren. Ich brauch also diesen verschlüsselten IV als HEX String.

Gruß Hagen

EDIT: und sende mal die Vektoren für sowas wie Obj.Encrypt('Teststring'); statt über die Dateien zu arbeiten. Du hast dort noch ein Preprozessing drinnen das einen String im MIME64 bearbeitet, aus einer Datei liest usw. und bei deinen obigen Testvektoren sind am Schluß immer die zeichen $0D + $0A das sind Carrige Return und Linefeed Steuercodes die in einem sinnvollem Testvektor nichts zu suchen haben.

[negaH]

Davon abgesehen stimmt mit deinen Testvektoren sowieso irgendwas nicht.

Code:

696D6C5666374861645137307A6C466C
516E6F2F73736937614A616C734E4C76
5830636751345930544E5432
--334C4C6752306256646C652F77735A3246704B6E5A654F6C6E686E2F586E4C4C4A6E3D3D0D0A^

Entschlüsselt 1:
CCF: [url]http://rapidshare.com/files/[/url] -- 58141435/voy402.part1.rar

------------------------------------------------------------------------------

Verschlüsselt 2:
696D6C5666374861645137307A6C466C
516E6F2F73736937614A616C734E4C76
5830636751345930544E5432
 --- 304434714341456B506573524D424B4930497A7A57357A3D0D0A

Entschlüsselt 2:
CCF: [url]http://rapidshare.com/files/[/url] --- 91891665/D2SC.rar

Wenn man bei beiden HEX Vektoren mal die Anzahl der sich dahinter verbergenden Zeichen zusammenzält die in beiden gleich snd so komme ich auf 44 Zeichen die gleich sind. Logisch das wir gleiches Passwort ohne Zufallssalt benutzen und die gleichen Daten verschlüsseln (übrigens kryptographisch unsicher !!) falls das Passwort immer gleich ist.

Nun zählen wir mal die Zeichen in deinem angeblichen String der verschlüsewlt wurde. Ich komme 33 Zeichen. Also WO zum Teufel sind die restlichen 11 Zeichen hin ? Vor deinem String "CCF:...." müssen noch 11 andere Zeichen sein, anders kann ich es mir nicht erklären. Nungut, denken wir uns mal das dieser String vor der Verschlüselung mit MIM Base 64 formatiert wurde, was ansich ja bescheuert wäre (kryptographisch betrachtet). Wenn wir einen 33 Zeichen-String in MIME64 umwandeln dann wird das Resulat im Verhältnis 3 zu 4 größer sein. Nun, 33*4/3 == ? ja 44.

Edit: anders ausgedrückt, deine Testvektoren sind für den Popo und repräsentieren nicht die Daten der eigentlichen Verschlüsselung.

[negaH]

So, du bist mir'ne Nuss ;)

Delphi-Quellcode:

function CCFDecrypt(const CCF: Binary; const Password: Binary): Binary;
begin
  with TCipher_Rijndael.Create do
  try
    Mode := cmCFB8;
    Init(Password);
    Result := DecodeBinary(CCF, TFormat_MIME64);
  finally
    Free;
  end;
end;

function CCFEncrypt(const CCF: Binary; const Password: Binary): Binary;
begin
  with TCipher_Rijndael.Create do
  try
    Mode := cmCFB8;
    Init(Password);
    Result := EncodeBinary(CCF, TFormat_MIME64);
  finally
    Free;
  end;
end;

procedure Test;
var
  Password, Data: Binary;
begin
  Password := TFormat_HEX.Decode('8C35192D964DC3182C6F84F3252239EB4A320D2500000000');

  Data := CCFEncrypt('CCF: http://rapidshare.com/files/58141435/voy402.part1.rar', Password);

  WriteLn('MIME64 : ', Data);
  WriteLn('HEX    : ', TFormat_HEX.Encode(Data));

  Data := CCFDecrypt(Data, Password);

  WriteLn('Data   : ', Data);

end;

raus kommt dann

Code:

MIME64 : imlVf7HadQ70zlFlQno/ssi7aJalsNLvX0cgQ4Y0TNT23LLgR0bVdle/wsZ2FpKnZeOlnhn/XnLLJg==
HEX    : 696D6C5666374861645137307A6C466C516E6F2F73736937614A616C734E4C765830636751345930544E54323
         34C4C6752306256646C652F77735A3246704B6E5A654F6C6E686E2F586E4C4C4A673D3D
Data   : CCF: [url]http://rapidshare.com/files/58141435/voy402.part1.rar[/url]

Wie du siehst brauscht du im DEC nur die richtigen Parameter einstellen und ohne Probleme funktioniert alles. Man sollte eben wissen WAS man da eigentlich als Datenformat so macht und gleich die richtigen Testvektoren liefern.

So das kostet dich ein Bier und da ich keines trinke könntest du uns an deiner fertigen Anwendung, RapidShare Tool, partizipieren lassen.

Gruß Hagen

EDIT: ach übrigens ich hoffe das es positiv auffällt mit wie wenig Sourcezeilen man das Gleiche in Delphi machen kann was im PHP umständlich geht ;)
EDIT: kryptographisch betrachtet ist diese Methode Dateien zu schützen unsicher, falls das Passwort nicht jedesmal neu per Zufall gewählt wird !

[q3fuba]

Erstmal muss ich sagen *respeckt* ! :)

aber jetzt habe ich noch folgendes problem:

mein test quelltext:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  MIME64, DataList: TStringList;
  MeinHexString, Password: string;
  i: integer;
begin

  Password := TFormat_HEX.Decode(Edit1.Text);
  MeinHexString:=Edit2.Text;

  MIME64 := TStringList.Create;
  DataList := TStringList.Create;
  MIME64.Text:=TFormat_HEX.Decode(MeinHexString);

  for i:=0 to MIME64.Count-1 do
  begin
    DataList.Append(CCFDecrypt(MIME64[i], Password));
  end;
  MIME64.SaveToFile('MIME64.txt');
  DataList.SaveToFile('Decrypted.txt');

in Edit1 steht mein Passwort in HEX:

Code:

8C35192D964DC3182C6F84F3252239EB4A320D2500000000

in Edit2 steht mein Verschlüsselter Text in HEX:

Code:

696D6C5666374861645137307A6C466C516E6F2F73736937614A616C734E4C765830636751345930544E5432304434714341456
B506573524D424B4930497A7A57357A3D0D0A387447614C6C6B4F3652643148314558386B414F55664B47494E486E4F346C6F37
6C4A31777233516E7867315234455571724D3752596F2F324F3335376B2B2F5A7639304E715976425456390D0A

Welcher entschlüsselt sein soll:

Code:

CCF: [url]http://rapidshare.com/files/91891665/D2SC.rar[/url]
CCF: [url]http://rapidshare.com/files/72806508/Forum_Tools.rar[/url]

aber raus kommt nur die erste zeile wie sie sein soll.
Denn es sieht dann so aus:

Code:

CCF: [url]http://rapidshare.com/files/91891665/D2SC.rar[/url]
;ÂZÔ˜zùÓ-,í^[rdshare.com/files/72806508/Forum_Tools.rar

Der text der zweiten zeile wird verstümmelt :?:
Auch wenn ich 10 zeilen haben, wird nur die erste zeile richtig enschlüsselt


Also, bis zu dem punkt:

Delphi-Quellcode:

MIME64.Text:=TFormat_HEX.Decode(MeinHexString);

stimmt noch alles, da bekomm ich 2 zeilen raus, welche ich dann jeweils einzelln decrypten müsste

Das kommt raus wenn ich "MeinHexString" decodiere

Code:

imlVf7HadQ70zlFlQno/ssi7aJalsNLvX0cgQ4Y0TNT20D4qCAEkPesRMBKI0IzzW5z=
8tGaLlkO6Rd1H1EX8kAOUfKGINHnO4lo7lJ1wr3Qnxg1R4EUqrM7RYo/2O357k+/Zv90NqYvBTV9

und das stimmt 100% mit dem überei, was mir das python script auch ausgiebt (habe ich getestet)

nur dann mach Phyton das:

Code:

base64.b64decode(zeile1)
obj.decrypt(zeile1)

base64.b64decode(zeile2)
obj.decrypt(zeile2)

also jede zeile einzelln decrypten

was wiederum für mich in delphi das ergeben würde:

Delphi-Quellcode:

  for i:=0 to MIME64.Count-1 do
  begin
    DataList.Append(CCFDecrypt(MIME64[i], Password));
  end;

mache ich das aber so, dann komm das raus:

Code:

CCF: [url]http://rapidshare.com/files/91891665/D2SC.rar[/url]
;ÂZÔ˜zùÓ-,í^[rdshare.com/files/72806508/Forum_Tools.rar

warum stimmt dann nur die erste zeile, aber die weiteren nicht? :gruebel:

[edit=Phoenix]Die lange Zeile umgebrochen wegen Layout. Mfg, Phoenix[/edit]

[negaH]

Weißt du was der PHP Code macht, wie er funktioniert ?

Als Hinweis: wie oft wird der Cipher erzeugt und mit einem Password gefüttert im Vergleich zu der Anzahl der Datenzeilen die man entschlüsselt ?

Delphi-Quellcode:

  with TCipher_Rijndael.Create do
  try
    Mode := cmCFB8;
    Init(TFormat_HEX.Decode('8C35192D964DC3182C6F84F3252239EB4A320D2500000000'));

    WriteLn(DecodeBinary('imlVf7HadQ70zlFlQno/ssi7aJalsNLvX0cgQ4Y0TNT20D4qCAEkPesRMBKI0IzzW5z=', TFormat_MIME64));
    WriteLn(DecodeBinary('8tGaLlkO6Rd1H1EX8kAOUfKGINHnO4lo7lJ1wr3Qnxg1R4EUqrM7RYo/2O357k+/Zv90NqYvBTV9', TFormat_MIME64));
  finally
    Free;
  end;

Delphi-Quellcode:

procedure CCFLoadFiles(AItems: Strings; const AFileName: String; const APassword: Binary);
var
  I: Integer;
begin
  AItems.BeginUpdate;
  try
    AItems.LoadFromFile(AFileName);
    AItems.Text := TFormat_HEX.Decode(AItems.Text);
    with TCipher_Rijndael.Create do
    try
      Mode := cmCFB8;
      Init(APassword);
      for I := 0 to AItems.Count -1 do
        AItems[I] := DecodeBinary(AItems[I], TFormat_MIME64);
    finally
      Free;
    end;
  finally
    AItems.EndUpdate;
  end;
end;

procedure TForm1.ButtonClick(Sender: TObject);
begin
  if OpenDialog1.Execute then
    CCFLoadFiles(ListBox1.Items, OpenDialog1.FileName, TFormat_HEX.Decode('8C35192D964DC3182C6F84F3252239EB4A320D2500000000'));
end;

Warum RapidShare das so verschlüsselt ist unklar. Man hätte

1.) mit einem Salt arbeiten müssen
2.) alle unverschlüsselten Zeilen als eine Zeile in einem Rutsch verschlüsseln können und dieses Resultat in einem Rutsch in MIME64 und dann nochmal in HEX umwandeln können.
3.) die Zusätzliche Umwandlung in HEX eines MIME64 String ist für den Popo und expandiert die Datenmenge nur unnötig. Es sei denn das DU diese HEX-Umwandlung eingebaut hast und in Wahrheit Rapidshare in seinen Dateien nur einfach zeilenweise MIME64 formatierte Strings enthalten. Das würde dieses ständige Umwandeln von HEX nach MIME64 erklären. Sollte das der Fall sein dann ändere oben Source um in

Delphi-Quellcode:

procedure CCFLoadFiles(AItems: Strings; const AFileName: String; const APassword: Binary);
var
  I: Integer;
begin
  AItems.BeginUpdate;
  try
    AItems.LoadFromFile(AFileName);
//    AItems.Text := TFormat_HEX.Decode(AItems.Text);
    with TCipher_Rijndael.Create do
    try
      Mode := cmCFB8;
      Init(APassword);
      for I := 0 to AItems.Count -1 do
        AItems[I] := DecodeBinary(AItems[I], TFormat_MIME64);
    finally
      Free;
    end;
  finally
    AItems.EndUpdate;
  end;
end;

Gruß Hagen

EDIT: erkläre uns doch mal was das eigentlich werden soll, ich möchte ungern unwissentlich in eine Straftat verwickelt werden. Davon abgesehen habe ich deine Arbeit gemacht und meine das alle hier im Forum interessierten Leute auch was davon haben sollten.

EDIT: übrigens sieht man sehr schön an Hand deiner fehlerhaften Resultate wie sich der Cipher sauber selbstsynchronisert. In deinem Output ist der 1. Datenblock a 16 Bytes der 2. Zeile zerstört. Aber alle nachfolgenden Datenblöcke sind wieder richtig. Das ist die Selbstsynchronisierung des Ciphers. Der 1. Datenblock ist deshalb falsch weil des interne Feedback-Register des Ciphers, 16 Bytes, neu mit einem Password initlaisiert wurde und nicht der letzte Wert aus der vorherigen 1. Zeile weiterbenutzt wurde. Da wir immer das gleiche Passwort benutzen, für jede Zeile separat, werden alle Datenblöcke nach dem 1. Datenblock wieder korrekt entschlüsselt. Für einen erfahrenen Laien ist also an Hand deines fehlerhaften Outputs sofort ersichtlich wo der Fehler im Source liegt, man erkennt sofort das der 1. Datenblock=16 Bytes falsch sind und stellt autom. die Vermutung auf das die Daten an einem Stück verschlüsselt wurden, auch ohne das PHP Script gesehen zu haben.

[negaH]

So nach kurzer Recherche weiß ich nun worum es geht. Mit nachfolgendem Code kann man RapidShare Containter Dateien mit Endung .RSDF entschlüsseln. So wie ich das interpretiere benutzt Rapidshare dabei zwar eine starke AES Verschlüsselung aber im Grunde vollkommen falsch. Ein Beispiel wie man es nicht machen sollte.

1.) das Passwort scheint hardcoded zu sein, kein Wunder das Cracker dieses schnell gefunden haben.
2.) das Passwort wird nicht mit einem Zufallssalt und einer KDF (Schlüsselableitungsfunktion) in einen pseudozufälligen Sessionkey umgewandelt, naja ist bei einem hardcoded Passwort auch sinnfällig.
Punkte 1. und 2. und die Tatsache das jeder Rapidshare Link immer mit 'CCIF: http://rapidshare....'' anfdangen haben die Konsequenz, das im verschlüsseltenm Resultat immer die gleichen Bytefolgen zu sehen sind. Man kann also als Angreifer, mit dem Wissen das die Dateien immer gleich anfangen, sehr schnell erkennen das ein hardcoded Passwort ohne Preprocessing des Passwortes benutzt wurde. Dazu muß man nur ein par dieser RSDF Dateien analysieren.
3.) das eigentliche Datenformat ist kompliziert und ineffizient. Man hat binäre Daten die man zeilenweise verschlüsselt und in MIME64 umwandelt obwohl sie am Stück mit einem Cipher Objekt verschlüsselt werden. Man kann also nicht beliebig eine dieser Zeile entschlüsseln ohne alle vorherigen Zeilen zu entschlüsseln. Ergo macht es auch keinen Sinn die einzelnen Zeilen separat und denoch abhängig voneinander zu verschlüsseln und in MIME64 umzuwandeln. Man hätte auch gleich die Daten in einem Rutsch verschlüsseln können. Dies wäre weit effizienter (schätze mal das dahinter ein PHP Script bei RapidShare steckt :) ) Die zusätzliche Umwandlung dieser Daten in das HEX Format ergibt technologisch betrachtet keinen Nutzen. Das INet kann ohne Probleme MIME64 formatierte Daten übertragen. Problematisch könnten nur die Zeilenumbrüche innerhalb dieses MIME64 String sein, wahrscheinlich auch der Grund für die Konvertierung in das HEX Format. Nur ist es eben so das diese zusätzlichen Zeilenumbrüche erst dadurch entstanden sind weil man sinnloser weise die einzelnen Dateinamen eben zeilenweise verschlüsselt und in MIME64 umgewandelt hat. Dieses ineffektive Datenformat ist also entstanden weil der Programmierer schon am Anfang einen konzeptionellen Fehler gemacht hat.
An Hand dieses Datenformates kann ein Angreifer gut erkennen das in einer RSDF Datei X Links gespeichert wurden, denn es gibt X Zeilen getrennt durch Zeilenumbrüche. Nun muß man nur noch ein RSDF File anlegen in dem mehrmals ein Link auf exakt die gleiche Datei gespeichert wurde. Analysiert man dieses verschlüsselte RSDF File so gäbe es zwei Möglichkeiten. Jede der Zeilen im File besteht aus exakt dem gleichen MIME64 String oder die Strings unterscheiden sich zeilenweise. Träfe erster Fall zu so würden wir wissen das jede Zeile mit neuem Passwort und Cipher Objekt verschlüsselt wurde, also so wie es der OP gemacht hat. Träfe der zweite Fall zu dann wissen wir das zeileweise verschlüsselt wurde aber mit nur einem einmalig initialiserten Cipher Objekt, so wie es auch der Fall ist. Also allein an Hand einer beeinflussbaren RapidShare Container Datei können wir enorm viele Informationen erlangen wie was verschlüsselt wurde. Der nächste und finale Schritt ist es den verwendeten Cipher samt Mode usw. und das hardcoded Passwort per Reverse Engineering der Download Software zu knacken, wir wissen ja nun wonach wir suchen müssen.
Das verwendete Dateiformat lässt also viel zu viele Informationen nach aussen dringen die es einem Angreifer leicht machen es zu knacken. Das Dateiformat ist also eine kryptographische Unsicherheit.

Delphi-Quellcode:

procedure RSDFLoadFiles(AItems: TStrings; const AFileName: String);
const
  Password = #$8C#$35#$19#$2D#$96#$4D#$C3#$18#$2C#$6F#$84#$F3#$25#$22#$39#$EB#$4A#$32#$0D#$25#$00#$00#$00#$00;

  function DoCleanup(const Value: String): String;
  begin
    Result := System.Copy(Value, Pos('HTTP', AnsiUpperCase(Value)), MaxInt);
  end;

var
  I: Integer;
begin
  AItems.BeginUpdate;
  try
    AItems.LoadFromFile(AFileName);
    AItems.Text := TFormat_HEX.Decode(AItems.Text);
    with TCipher_Rijndael.Create do
    try
      Mode := cmCFB8;
      Init(Password);
      for I := 0 to AItems.Count -1 do
        AItems[I] := DoCleanup(DecodeBinary(AItems[I], TFormat_MIME64));
    finally
      Free;
    end;
  finally
    AItems.EndUpdate;
  end;
end;

Damit das funktioniert müsst ihr in DECFmt.pas folgendes ändern:

Delphi-Quellcode:

class function TFormat_HEX.DoDecode(const Value; Size: Integer): Binary;
var
  S: PChar;
  D: PByte;
  T: PChar;
  I,P: Integer;
  HasIdent: Boolean;
begin
  Result := '';
  if Size <= 0 then Exit;
  SetLength(Result, Size div 2 +1);
  T := CharTable;
  D := PByte(Result);
  S := PChar(@Value);
  I := 0;
  HasIdent := False;
  while Size > 0 do
  begin
    P := TableFind(S^, T, 18);
    if P < 0 then P := TableFind(UpCase(S^), T, MaxInt);
    if P < 0 then
      raise EDECException.CreateFmt(sInvalidStringFormat, [DECClassname(Self)]);
    Inc(S);
    if P >= 0 then
      if P > 16 then
      begin
        if not HasIdent and (P < 18) then
        begin
          HasIdent := True;
          I := 0;
          D := PByte(Result);
        end;
      end else
      begin
        if Odd(I) then
        begin
          D^ := D^ or P;
          Inc(D);
        end else D^ := P shl 4;
        Inc(I);
      end;
    Dec(Size);
  end;
  SetLength(Result, PChar(D) - PChar(Result));
end;

Der HEX String in einer RSDF Datei enthält am Ende ein '/n' bzw. eben ein #13#10 -> Carrige Return + Linefeed. Meine originale HEX Konvertierungsfunktion hat diese Steuerzeichen nicht rausgefiltert. Logisch betrachtet ein Fehler im DEC.

Gruß Hagen

[negaH]

Ach und nochwas ;)

Der Cipher wird im CFB8 Modus betrieben. Das ist quasi ein Blockcipher der in einen Streamcipher umgewandelt wird. Das besondere daran ist das nun der AES ausgehend vom Passwort nur einen Schlüsselstrom aus Bytes erzeugt. Dieser Schlüselstrom wird dann mit den Daten XOR verknüpft. Das ist unsicher !!
Denn nun machen wir einfach mal folgendes Experiment. Wir legen eine Rapidshare Account an und lassen ein Containerfile erzeugen das möglichst viele Links enthält. Alle Links in der gleichen Reihenfolge. Dann nehmen wir unsere Rapidshare Datei ent-HEX'en sie, und ent'MIME64 sie und verknüpfen beide Daten per XOR. Nun haben wir den Schlüsselstrom extrahiert. Da das Passwort hardcoded und unveränderlich ist, da der IV nicht per Zufall gewählt wurde und auch kein Zufallssalt eingebaut wurde, können wir diesen Schlüsselstom driekt benutzen um alle Rapidshare Dateien zu entschlüsseln. Also ohne das Passwort noch den AES Cipheralgortihmus zu kennen knacken wir alle Rapidshare Dateien. Naja, kryptographisch betrachtet also nicht besser als eine XOR Verschlüsslung oder sonstwas billiges.

Merke:
- Passwörter immer per Salt umwandeln
- Daten nach Möglichkeit randomisieren am Anfang
- nach Möglichkeit immer alle Daten am Stück verschlüsseln
- niemals ein hardcoded Passwort benutzen
- einen Blockcipher am besten in einem Ciphermode betreiben der auch wirklich blockweise die Daten verschlüsselt und nicht wie einen Streamcipher benutzen.

Gruß Hagen

[q3fuba]

Oh mann...
Das hätte ich in nem jahr alleine nicht hinbekommen :P

Ich denke aber auch, dass die rsdf files nur soweit "verschlüsselt" sind, damit die nicht jeder lesen kann, was wiederum eigentlich voll für'n hugo ist, aber naja dafür kann ich leider nichts :D

Zitat:

Der HEX String in einer RSDF Datei enthält am Ende ein '/n' bzw. eben ein #13#10 -> Carrige Return + Linefeed. Meine originale HEX Konvertierungsfunktion hat diese Steuerzeichen nicht rausgefiltert. Logisch betrachtet ein Fehler im DEC.

naja, wer rechnet den mit sowas?
soll ja ne Delphi decrypting unit sein, nicht eine von php abgeleitet.

Aber allgemein gesehen, weil ich ja von crypting und co NICHT annähernd soviel ahnung habe wie du, muss ich sagen, *respeckt*!

Mein programm sollte ja eigentlich nur die links aus der rsdf rausfiltern und dann in ne list / datei lesbar wieder abspeichern.

Zitat:

Der Cipher wird im CFB8 Modus betrieben. Das ist quasi ein Blockcipher der in einen Streamcipher umgewandelt wird. Das besondere daran ist das nun der AES ausgehend vom Passwort nur einen Schlüsselstrom aus Bytes erzeugt. Dieser Schlüselstrom wird dann mit den Daten XOR verknüpft. Das ist unsicher !!

Aber trotzdem hat es leute wie mich, davon abgehalten, den code "einfach" zu decrypten.
Naja wenn man nicht allzuviel ahnung hat, ist das auch nicht schwer und genau darum geht es ihnen denke ich.


Aber egal, ich habe das kleine tool, welches ich eigentlich machen wollte man angefügt.
Natürlich habe ich auch dich darin erwähnt!

Sag mir was du davon hälst :D

[negaH]

Ausführbare Dateien werde ich mir nicht anschauen, verständlich oder :) Ich möchte dir damit keine bösen Absichten unterstellen sondern nur meinen Rechner sauber halten.

EDIT: ich schrieb

Zitat:

Der Cipher wird im CFB8 Modus betrieben. Das ist quasi ein Blockcipher der in einen Streamcipher umgewandelt wird. Das besondere daran ist das nun der AES ausgehend vom Passwort nur einen Schlüsselstrom aus Bytes erzeugt. Dieser Schlüselstrom wird dann mit den Daten XOR verknüpft. Das ist unsicher !!

Ist natürlich falsch und bezieht sich auf dem OFB8 -> Output Feedback Modus und nicht CFB8 -> Cipher Feedback Modus. Der CFB8 ist im Gegensatz zum OFB8 auch abhängig vom Datenstrom der verschlüsselt wird. Das hat zur Konsequenz das man nicht auf einfache Weise einen Schlüsselstrom zu einem unbekannten Passwort nur mit Hilfe der unverschlüsselten und verschlüsselten Daten extrahieren kann. Beim OFB8 geht das aber, deshalb muß man beim OFB auch immer das Passwort oder IV randomisieren.

Gruß Hagen

http://de.wikipedia.org/wiki/Respekt

[q3fuba]

Zitat:

Ausführbare Dateien werde ich mir nicht anschauen, verständlich oder Smile Ich möchte dir damit keine bösen Absichten unterstellen sondern nur meinen Rechner sauber halten.

jo, ist verständlich.

Zitat:

http://de.wikipedia.org/wiki/Respekt

grml, da verschreibt man sich mal und wird gleich belehrt :P

aber mal was anderes...
Wo/wie sollte ich beim Crypting anfangen?
Weil ich bin ja in dem gebiet ja ne null und würde mich da gerne mal weiterentwickeln ;)
Was muss ich verstehen usw...

Hast da irgendwelche infos für mich? :D

[negaH]

Zitat:

grml, da verschreibt man sich mal und wird gleich belehrt Razz

Ach komm, ich habe schon sehr dezent darauf hingewiesen. Du warst es der deinen Fehler auch noch fett hervorgehoben hat. Für mich ist es eher zum Schmunzeln, ab-specken -> re-specken mit Respekt, wäre doch mal was für Weight Watchers. Davon abgesehen sind wir Kollegen und da meine ich kann man mal auf solche Kleinigkeiten hinweisen, ist also keine Kritik oder Lustigmachen meinerseits.

Zitat:

aber mal was anderes...
Wo/wie sollte ich beim Crypting anfangen?
Weil ich bin ja in dem gebiet ja ne null und würde mich da gerne mal weiterentwickeln Wink
Was muss ich verstehen usw...

Hast da irgendwelche infos für mich?

Du kannst im WEB einige gute Einführungsseite über kryptographie sogar in deutsch finden. Du solltest dann halt die Eigenwerbung für deren Produkte einfach mal ausblenden. Aber noch besser, viel sachlicher, umfangreicher und sogwar witzig finde ich als Einstieg Bruce Schneier's Buch "Angewandte Kryptographie" ISBN 3-89319-854-7. Nicht mehr ganz auf dem neusten Stand besonders wenn es im Detail um die asymmetrische Kryptographie geht, aber denoch der beste Einstieg in Buchform. Weiter gehts danach mit "Handbook of Applied Cryptography", kurz HAC genannt, von A.Menzes, P.C.v.Oorschot und S.A.Vanstone. ISBN 0-8493-8523-7 und wie leicht erkennbar nur in englisch verfügbar. Mit diesem Wälzer bekommst du den Einstieg besonders in dei Welt der asymmetrischen Verfahren und der dahinterliegenden Mathematik, sehr spannend. Aber auch dieses Buch kann die Entwicklungen der letzten 5-10 Jahre nicht widerspiegeln, besonders im Bereich der Elliptischen Kurven usw. Möchtest du noch tiefer in den Sumpf der asozialen Mathematik ;) abgleiten, quasi hardcore, dann tue dir unseren lieben Henri Cohen an. "A Course in Computational Algebraic Number Theory" ISBN 0-387-55640, alles was du über Zahlentheory und somit die Grundlage heutiger Kryptographie benötigst, wenn man es noch versteht ;)
Möchtest du auf dem neusten Stand sein so bleibt dir nur das WEB und die dort veröffentlichten Abhandlungen, Dissertationen von angehenden Doktoren/Professoren, die Patentdatenbanken usw. übrig. Dazu brauchst du auf alle Fälle einen gute PostScript Viewer, ich nehme gsView, fundierte Englischkenntnisse und ein gewisses Gespür beim Auffunden dieser Dokumente. Leider hat da sehr stark der Kommerz einzug gehalten und so bezahlt man sehr oft für eine "Dienstleistung" die nict hält was sie verspricht. Sprich, sehr oft lädt man solche mahtmatischen Abhandlungen runter, mit großartigem Titel, und bemerkt erst nach tagen das das was da drinnen steht schon längst als Implementation in deiner eigenen Library drinen ist, einfach weil es triviale Geschichten sind. Naja ist halt das Akademikervolk das sich da profiliert. So all in all beträgt meine Bibliothek mit solchen Dokumenten um die 4Gb gezippt.
Bleiben noch die vielen guten OpenSource Libraries wie Wai Dai's CryptoLIB, GMP, Miracle, hpFloat usw. Diese sind meistens, quasi fast immer, in Asm, C oder C++ geschrieben und das desöfteren mit allen Geschossen die zb. C++ anzubieten hat, also beileibe nicht einfach zu verstehen.
Versuche dabei aber freie Source wie RSAInc. PKCS, OpenPGP, ASN.1 usw. erstmal zu umgehen, denn diese konzentrieren sich erstmal nur auf irgendwelche Standars/Protokolle und das meistens schwer nachvollziehbar. Natürlich auch meistens in C/C++.

Gruß Hagen

[q3fuba]

Zitat:

Ach komm, ich habe schon sehr dezent darauf hingewiesen. Du warst es der deinen Fehler auch noch fett hervorgehoben hat. Für mich ist es eher zum Schmunzeln, ab-specken -> re-specken mit Respekt, wäre doch mal was für Weight Watchers. Davon abgesehen sind wir Kollegen und da meine ich kann man mal auf solche Kleinigkeiten hinweisen, ist also keine Kritik oder Lustigmachen meinerseits.

auch meine antwort darauf war genau das selbe, du darfst mich auch nicht falsch verstehen.
Auf jede aktion, erfolgt eine gegenaktion und ich dachte mir schon, dass dies nur als "witz" gemeint war.
Deswegen auch mein gegenargument :D

Und danke für den tip mit den büchern, ich werde natürlich mal "unten" anfangen müssen um später alles zu verstehen.
Ich beziehe mich da immer gern darauf, wie es bei den OS's war, habe auch noch mit MS-DOS angefangen und wenn man heute jemand danach fragt, weiß dieser meist, grob gesagt, nichtmal was das überhaupt ist :D

-> Es ist ja noch kein Meister vom Himmel gefallen (soweit ich weiß) :P

[seim]

Zitat:

Zitat von negaH

EDIT: erkläre uns doch mal was das eigentlich werden soll, ich möchte ungern unwissentlich in eine Straftat verwickelt werden. Davon abgesehen habe ich deine Arbeit gemacht und meine das alle hier im Forum interessierten Leute auch was davon haben sollten.

Ich kann euch sagen, dass das entschlüsseln von rsdf oder ccf Files nicht gegen geltendes Recht verstößt.
Atm werden diese Files wohl benutzt um Links zu verschlüsseln. Downloadmanager ziehen diese Files ein und laden die Dateien runter ohne das der User die Links zu Gesicht bekommt.
Was ihr hier gerade gemacht habt wird allerdings von einigen Leuten die solche Container benutzten nicht gern gesehen, da so Links "verpetzt" werden können so nach dem Motto: "Ej ihr Leute von Rapidshare, guck ma das sind die Links aus der kinofilme.rsdf Datei, alles illegale Files." - "Ah, ok wir löschen diese Dateien."

[Novo]

Hm, gestern gings noch, heute wird mir mit deinem Source (Das vom Dateianhang) angezeigt:
Bei:

Delphi-Quellcode:

ListBox1.Items.Text:=RSDFLoad(OpenDialog1.FileName);

->
Input is not an valid HEX Format.



Was mache ich falsch?
ich habe DEC einmal mit geänderter DECFmt.pas probiert, einmal ohne...

Alles nochmal sauber installiert, nix!



Dann achte ich mir, ok machste das mit der DecryptRSDF.exe und parameter...
Leider akzeptiert er kein

Delphi-Quellcode:

ExtractFilePath(0)+DecryptRSDF.exe -d ExtractFilePath(0)+'test.rsdf' ExtractFilePath(0)+'out.txt'

Da sagt er mir, RSDF nicht gefunden ...


Ich würde jetzt aber gerne auch andersrum machen, Links in rsdf verschlüsseln



kann mir da einer Helfen bitte?

[Novo]

Bitte um Hilfe!

[magoo2002de]

@ Novo: das müsste so gehen

Delphi-Quellcode:

procedure RSDFSaveFiles(AItems: TStrings; const AFileName: String);
const
  Password = #$8C#$35#$19#$2D#$96#$4D#$C3#$18#$2C#$6F#$84#$F3#$25#$22#$39#$EB#$4A#$32#$0D#$25#$00#$00#$00#$00;
var
  I: Integer;
begin
  with TCipher_Rijndael.Create do
  try
    Mode := cmCFB8;
    Init(Password);
    for I := 0 to AItems.Count -1 do
      AItems[I] := 'CCF: '+EncodeBinary(AItems[I], TFormat_MIME64);
  finally
    Free;
  end;
  AItems.Text := TFormat_HEX.Encode(AItems.Text);
  AItems.SaveToFile(AFileName);
end;

Mich würde nun interessieren, wie man das mit DCPCrypt2 umsetzt. Ich habe es wie folgt probiert, jdeoch leider ohne Erfolg:

Delphi-Quellcode:

function HexToStr(s: String): String;
var
  i: Integer;
begin
  Result:=''; i:=1;
  while i<Length(s) do begin
    Result:=Result+Chr(StrToIntDef('$'+Copy(s,i,2),0));
    Inc(i,2);
  end;
end;

function PadWithZeros(const str : string; size : integer) : string;
var
  origsize, i : integer;
begin
  Result := str;
  origsize := Length(Result);
  if ((origsize mod size) <> 0) or (origsize = 0) then
  begin
    SetLength(Result,((origsize div size)+1)*size);
    for i := origsize+1 to Length(Result) do
      Result[i] := #0;
  end;
end;

procedure TMainForm.LoadRSDF(Filename: String);
var
  I1:Integer;
  tmpLst1: TStringList;
  tmpStr1, RSDFKey, RSDFIV: String;
  Cipher : TDCP_rijndael;
begin
  RSDFKey := PadWithZeros('8C35192D964DC3182C6F84F3252239EB4A320D25', 32);
  RSDFIV := PadWithZeros('', 16);
  tmpLst1 := TStringList.Create;
  tmpLst1.LoadFromFile(Filename);
  tmpLst1.Text := HexToStr(tmpLst1.Text);
  for I1 := 0 to tmpLst1.Count - 1 do
  begin
    tmpStr1 := Base64DecodeStr(tmpLst1.Strings[I1]);
    Cipher := TDCP_rijndael.Create(Self);
    Cipher.Init(RSDFKey[1],128,@RSDFIV[1]);
    Cipher.DecryptCFB8bit(tmpStr1[1],tmpStr1[1],Length(tmpStr1));
    Cipher.Free;
    tmpLst1.Strings[I1] := tmpStr1;
  end;
  Memo1.Text := tmpLst1.Text;
  tmpLst1.Free;
end;

[magoo2002de]

Schade, dass keiner bisher eine Antwort für mich hat :(
Das wäre echt super gewesen.

[BenjZim]

Wie muss man denn die DECFmt.pas ändern, damit sie auch unter Delphi XE2 funktioniert?
Ich habe es von http://code.google.com/p/delphidec/downloads/list heruntergeladen.

Vielen Dank

[mkinzler]

Alternative TurboPower LockBox

[DeddyH]

Oder mal beim Kryptochef (persönlich!) nachfragen :mrgreen: :duck:

[BUG]

Assertor betreut afaik den aktuellen Stand des DEC.
Vielleicht kann er dir mehr dazu sagen.