DEC 5.2 mit Vector deccipher Umbau von DOT net auf Delphi

[Digielm]

Hallo leute ich versuche grade unsere Lizenzsierung von einem Dot Net Projekt umzubauen und scheitere an den Vector eigenschaften.

Code:

            
string passPhrase = "123457890";
            string saltValue = "0987654321";
            string hashAlgorithm = "MD5";
            int passwordIterations = 2;
            string initVector = "@1B21337e5F6g7H8";
            int keySize = 256;
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

            PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                            passPhrase,
                                                            saltValueBytes,
                                                            hashAlgorithm,
                                                            passwordIterations);

            
            byte[] keyBytes = password.GetBytes(keySize / 8);

            RijndaelManaged symmetricKey = new RijndaelManaged();

            symmetricKey.Mode = CipherMode.CBC;

            ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
                                                             keyBytes,
                                                             initVectorBytes);

[COLOR="Red"]            MemoryStream memoryStream = new MemoryStream();

            CryptoStream cryptoStream = new CryptoStream(memoryStream,
                                                         encryptor,
                                                         CryptoStreamMode.Write);
            cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

            cryptoStream.FlushFinalBlock();

            byte[] cipherTextBytes = memoryStream.ToArray();

            memoryStream.Close();
            cryptoStream.Close();

            string cipherText = Convert.ToBase64String(cipherTextBytes);[/COLOR]            return cipherText;

Ich habe es soweit geschaft nur komme ich mit der DOT Funktion CryptoStream nicht wirklich weiter.

Hier habe ich den Source in Delphi mal eingebaut

Delphi-Quellcode:

        licenc := TCipher_Rijndael.Create;
        licenc.Mode := cmCBCx;

        password := THash_MD5.KDFx('0123456789', '0987654321', 2);
        licenc.Init(password);
        Encoded := licenc.DecodeBinary(sn, TFormat_MIME64);

leider bekomme ich einen ganz anderen Hash zurück als im DOT Net Projekt.

Wer kann mir helfen.

[Bernhard Geyer]

Der String-Typ in Delphi ist bei D2009 UnicodeString. Im .NET verwendest du die ANSI-Codierung!

[Digielm]

Ja habe das auch schon ausprobiert.

Das Problem bei der Umstellung ist der initvector den ich allerdings in Delphi nirgends übergeben kann um das ganze nochmals zu verschieben beim crypten.

[ToFaceTeKilla]

Hi,

ich stehe gerade vor einem ähnlichen Problem wie der OP:

Wir nutzen die gleiche C#-Funktion zum Verschlüsseln (copy-paste von irgendwo aus dem Netz, würde ich da jetzt mal behaupten).
Ich muss das jetzt auf der anderen Seite wieder mit Delphi entschlüsseln. Da habe ich mir das sagenumwobene DEC zur Hilfe genommen und es nach langem Fummeln und viel Lesen (div. Threads hier in der DP zum Thema DEC und Rijndael) auch geschafft, es so zu benutzen, dass ich etwas ver- und auch wieder entschlüsseln kann.
Wenn ich da jetzt allerdings die mit der C#-Funktion verschlüsselten Daten reinstopfe, bekomme ich nur Zeichen-Salat raus.
Hier mein Code:

Delphi-Quellcode:

function DecryptBase64Str(const CipherText_Base64: Binary; const Password: Binary; const Salt: Binary; const InitVector: string): string;
var
  rind: TCipher_Rijndael;
  pass: string;
begin
  rind:= TCipher_Rijndael.Create;
  rind.Mode:= cmCBCx;
  pass:= THash_SHA1.KDFx(Password,salt,rind.Context.KeySize);
  rind.Init(pass,Length(pass),InitVector,SizeOf(InitVector));
  Result:= rind.DecodeBinary(TFormat_MIME64.Decode(CipherText_Base64));
end;

Könnte es an der KDF liegen? PasswordDeriveBytes benutzt PBKDF1, was benutzt DEC?
Weiß einer, wie die Umkehrung des C#-Codes in Delphi aussieht?

Vielen Dank schonmal!

[mkinzler]

Für TurboPower LockBox3 gibt es hierzu eine Beitrag bei SO
http://stackoverflow.com/questions/1...ing-for-aes-25

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206161)

PasswordDeriveBytes benutzt PBKDF1, was benutzt DEC?

Kann man doch nachlesen: "class function TDECHash.KDFx // DEC's own KDF, even stronger" :wink:

Ich kann beim besten Willen nicht sagen, was DEC benutzt. Auf jeden Fall ist KDF1/2 nicht gleich PKDF1/2.

Pascal-Implementationen der wichtigsten KDFs sind in der Unit kdf.pas in meinem CRC/HASH/HMAC-Paket. Die darin enthaltene PBKDF1-Funktion ist getestet mit http://www.di-mgt.com.au/cryptoKDFs.html und LibTomCrypt.

[ToFaceTeKilla]

Danke für die Antworten.

@mkinzler:
Wenn es nicht anders geht, probiere ich mal noch LB aus. Ich hatte das verworfen, weil es laut der Projektseite ja schon gar nicht vorgesehen ist, dass man den IV bestimmt. Und in irgendeinem Thread hier hatte gammatester auch gemeint, LB wäre langsam.

@gammatester:
Danke, das hatte ich auch gelesen ;-) Ich hatte es zwischenzeitlich auch mit der KDF2-Funktion probiert, da steht ja als Kommentar

Delphi-Quellcode:

// Key Generation Function 2, IEEE P1363 Working Group

Unter der IEEE-Nr. habe ich allerdings nichts in Richtung KDF gefunden (ok, ich gebe zu, das ganze Crypto-Zeug ist mir bisschen ein Rätsel :cyclops:). Weißt du, was dahinter steckt?
Deine Lib habe ich gestern dann direkt mal ausprobiert. Ich scheitere allerdings an der Hash-Registrierung. Gibts da irgendwo eine Demo oder eine Anleitung? Auf deiner Seite steht zwar "pb_kdf functions are used in the FCA and FZCA demo programs. ", aber gefunden habe ich diese nicht :?

Recht herzlichen Dank für die Aufmerksamkeit!

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206302)

Ich scheitere allerdings an der Hash-Registrierung. Gibts da irgendwo eine Demo oder eine Anleitung?

Es gibt die englische Einführung und viele Testprogramme als Besipiele; für Dich wohl interessant das Program t_kdf.pas mit dem Test für KDF1 in

Delphi-Quellcode:

procedure CryptoSys_Tests;
  {-Vectors from http://www.di-mgt.com.au/cryptoKDFs.html}
//..
  phash := FindHash_by_ID(_SHA1);
  if phash=nil then begin
    writeln('Hash SHA1 not registered/found');
    exit;
  end;

  err := kdf1(phash, @Z, sizeof(Z), nil, 0, key, 32);
  write('   kdf1: ');
  if err=0 then writeln(compmem(@key,@K1,sizeof(K1)))
  else writeln(' err=',err);
//..

Hier wird SHA1 benutzt, wenn Du MD5 verwenden willst, gehts entsprechend mit

Delphi-Quellcode:

phash := FindHash_by_ID(_MD5);

oder

Delphi-Quellcode:

phash := FindHash_by_Name('MD5');

. Wichtig ist (wie in der Einführung beschrieben), daß die Unit mit der Hashfunktion auch wirklich eingebunden wird, zB durch explizites uses md5;

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206302)

Auf deiner Seite steht zwar "pb_kdf functions are used in the FCA and FZCA demo programs. ", aber gefunden habe ich diese nicht :?

Na zB in der Unit fcrypta (File crypt/authenticate unit):

Delphi-Quellcode:

function FCA_EAX_init(var cx: TAES_EAXContext; pPW: pointer; pLen: word; var hdr: TFCAHdr): integer;
  {-Initialize crypt context using password pointer pPW and hdr.salt}
var
  XKey: TXKey;
  Err : integer;
begin

  {derive the EAX key / nonce and pw verifier}
  Err := pbkdf2(FindHash_by_ID(_SHA1), pPW, pLen, @hdr.salt, sizeof(TFCASalt), KeyIterations, XKey, sizeof(XKey));

  {init AES EAX mode with ak/hk}
  if Err=0 then Err := AES_EAX_Init(XKey.ak, 8*sizeof(XKey.ak), xkey.hk, sizeof(XKey.hk), cx);;

  {exit if any error}
  FCA_EAX_init := Err;
  if Err<>0 then exit;

  {return pw verifier}
  hdr.PW_Ver := XKey.pv;
  hdr.FCASig := C_FCA_Sig;
  hdr.Flags  := $A1;

  {burn XKey}
  fillchar(XKey, sizeof(XKey),0);
end;

Edit: Oder meinst Du, daß Du die Demoprogramme nicht gefunden hast? Die sind hier zu finden:
http://www.wolfgang-ehrhardt.de/crypt_de.html#FCADemo

[ToFaceTeKilla]

So ich habe jetzt wieder etwas rumprobiert und mir deine Beispielunits vorgenommen.
Da ich ja nur auf der Suche nach einer pbkdf1-Implementierung war, habe ich die von dir genommen (siehe unten) und dazu die Rijndael-Implementierung aus dem DEC. Das Key-Array habe ich entsprechend dem Beispiel in der t_kdf.pas
gewählt. Hier wirft rind.Init() allerdings den Fehler, der Key wäre zu groß.
Wenn ich den auf ein 20-Byte-Array reduziere (entsprechend der RFC), dann kommt stattdessen die Fehlermeldung,
der IV wäre zu groß. Der IV ist im konkreten Beispiel '2013-02-14 15:45:07.307', das Salt ein 6-Zeichen-String.

Was mache ich falsch? Funktioniert das überhaupt zusammen mit dem DEC oder muss ich AES_CBC_Decrypt aus deiner Lib nehmen? Wenn ja, könntest du mir da bitte erläutern, was die
Parameter bedeuten bzw. was da rein muss?

Delphi-Quellcode:

function DecryptBase64Str(const CipherText_Base64: Binary; const Password: Binary; const Salt: Binary; const InitVector: string): string;
var
  key: array[0..63] of byte;  
  rind: TCipher_Rijndael;
  pass: string;
  hash: PHashDesc;
  ctx: TAESContext;
begin  
  rind:= TCipher_Rijndael.Create;
  rind.Mode:= cmCBCx;
  hash:= FindHash_by_ID(_SHA1);
  pbkdf1(hash,@Password, SizeOf(password),@Salt,2,key,16);//SizeOf(key));
  rind.Init(key,Length(key),InitVector,SizeOf(InitVector));
  Result:= rind.DecodeBinary(TFormat_MIME64.Decode(CipherText_Base64));
end;

Danke nochmal

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206481)

Was mache ich falsch? Funktioniert das überhaupt zusammen mit dem DEC oder muss ich AES_CBC_Decrypt aus deiner Lib nehmen? Wenn ja, könntest du mir da bitte erläutern, was die Parameter bedeuten bzw. was da rein muss?

Ja Du machst mM was falsch, und eigentlich sollte das mit dem DEC dann funktionieren. Du willst doch offensichtlich AES-128 benutzen, jedenfalls wird mit

Delphi-Quellcode:

pbkdf1(hash,@Password, SizeOf(password),@Salt,2,key,16);

ein 16-Byte = 128-Bit Schlüssel generiert. Mit

Delphi-Quellcode:

var
  key: array[0..63] of byte; 
//..
rind.Init(key,Length(key),InitVector,SizeOf(InitVector));

stopfst Du aber 512-Bit in die Init-Routine, was den Fehler 'Zu großer Key' erklärt. Am einfachsten änderst Du die key-deklaration in

Delphi-Quellcode:

var
  key: array[0..15] of byte;

oder verwendest explizit den Wert 16 in

Delphi-Quellcode:

//..
rind.Init(key,16,InitVector,SizeOf(InitVector));

Laß Dir doch einmal auf beiden Seiten den erzeugten Schlüssel an zeigen.

Wenn Du Glück hast, läuft es dann mit dieser Änderung. (Ich bin allerdings immer mißtrauisch wenn in DEC sowas wie cmCBCx auftaucht. Wenn die Kryptotextlänge kein Vielfaches von 16 ist, schaltet mW DEC in einen Spezialmodus - der Fairness halber: auch mein AES_CBC benutzt dann CipherTextStealing). Wenn Du mein AES verwenden willst, must Du einige Dinge 'zu Fuß' erledigen: Base64-Umwandlung, eventuell Padding (die Parameter sind eigentlich immer ctp: Pointer auf Ciphertext, ptp: Pointer auf Plaintext).

[gammatester]

Wenn ich mir den gesamten Thread noch einmal ansehe, tauchen eine Punkte auf, die zu klären sind: Der Origialbeitrag arbeitet mit 256-Bit Schlüsseln und MD5. Du sagst, Ihr benutzt die gleiche C#-Funktion, verwendest aber in den Codebeispielen 128-Bit-Schüssel und SHA1?

Auf jeden Fall ist ein IV für AES 16-Bytes groß und deshalb sowas wie '2013-02-14 15:45:07.307' nicht zulässig. Also muß ein IV noch irgendwie daraus generiert werden. Daß ist zwar kein Problem als solches, aber der gleiche IV muß halt auf beiden Seiten verwendet werden: Also übertragen oder auf Empfängerseite generieren. Ein fixer IV ist keine gute Idee!

[ToFaceTeKilla]

Ja da hast du natürlich recht. Wir arbeiten auch mit 256-Bit-Schlüsseln, so wie im Bsp. Die 16-Byte die ich in den Codeschnippseln stehen habe, sind da aufgrund des Rumprobierens gelandet (weil ich wirklich KEINE Ahnung hatte, in welchem Zusammenhang das steht). Hab das jetzt entsprechend auch auf 32 Byte geändert.
Im Gegensatz zum OP benutzen wir aber SHA-1 auf C#-Seite, aber das sollte ja weiter keine Rolle spielen oder?
Der IV wird mit übertragen. Also kann ich den Timestamp so nehmen, ja?

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206506)

Im Gegensatz zum OP benutzen wir aber SHA-1 auf C#-Seite, aber das sollte ja weiter keine Rolle spielen oder?
Der IV wird mit übertragen. Also kann ich den Timestamp so nehmen, ja?

Vermutlich ja, das hängt von DEC und dem 'Protokoll' ab. Fakt ist, daß ein AES-IV (im engeren Sinn) 16 Bytes hat (wie auch '@1B21337e5F6g7H8' im Original).

Wenn DEC aus der Zeit 16 Bytes für den eigentlichen IV destilliert und zB dem Ciphertext voranstellt, Base-64 kodiert..., dann muß halt die Empfängerseite darauf eingerichtet sein und das ganze in umgekehrten Reihgenfolge aufdröseln: Base64 decodieren, IV separieren, entschüsseln... Der Empfängerseite kann es dann egal sein, wie der IV generiert wurde.

[ToFaceTeKilla]

Nächstes Problem: da ja SHA-1 nur 160-Bit-Output hat (wenn ich das richtig verstehe), hab ich die verwendete Hash-Funktion auf SHA-256 geändert.
Um das überhaupt erstmal zum Funktionieren zu bringen, ver- und entschlüssel ich jetzt erstmal testhalber in Delphi. Dabei ist mir aufgefallen, dass der Aufruf von

Delphi-Quellcode:

pbkdf1s(hash,Password,@Salt,2,key,32);

in der Verschlüsselungsfunktion einen anderen Key ergibt als in der Entschlüsselungsfunktion mit selben Parametern.
Sollte das nicht gleich sein, damit der gleiche Schlüssel erzeugt wird? Ich bin etwas ratlos :|

Edit: OK, mir ist grad wieder eingefallen, dass PBKDF1 nur 160-Bit unterstützt, also hab ich auf SHA-1 zurückgeändert, den Key als array of byte [0..19] deklariert und als dkLen 20 angegeben. Ändert aber nix daran, dass die Keys unterschiedlich sind.

Edit2: Bin jetzt erstmal eine Woche im Urlaub, also nicht sauer sein, wenn ich nicht mehr reagiere ^^

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206521)

Nächstes Problem: da ja SHA-1 nur 160-Bit-Output hat (wenn ich das richtig verstehe), hab ich die verwendete Hash-Funktion auf SHA-256 geändert.
...
Edit: OK, mir ist grad wieder eingefallen, dass PBKDF1 nur 160-Bit unterstützt, also hab ich auf SHA-1 zurückgeändert, den Key als array of byte [0..19] deklariert und als dkLen 20 angegeben. Ändert aber nix daran, dass die Keys unterschiedlich sind.

Vielleicht solltest Du zuerst einmal klären, welche KDF die C#-Funktion PasswordDeriveBytes verwendet. Warum verwendest Du ausgerechnet PBKDF1, das als einzige Funktion eine Maximallänge (= Hashlänge) hat? Der Originalcode kann so nicht funktioniert haben mit 128-Bit-Hash und 256-Bit-Schlüssel.

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1206521)

Um das überhaupt erstmal zum Funktionieren zu bringen, ver- und entschlüssel ich jetzt erstmal testhalber in Delphi. Dabei ist mir aufgefallen, dass der Aufruf von

Delphi-Quellcode:

pbkdf1s(hash,Password,@Salt,2,key,32);

in der Verschlüsselungsfunktion einen anderen Key ergibt als in der Entschlüsselungsfunktion mit selben Parametern.
Sollte das nicht gleich sein, damit der gleiche Schlüssel erzeugt wird? Ich bin etwas ratlos :|

Bist Du sicher, daß beides mal die gleichen Eingangsdaten benutzt wurden? Insbesondere muß natürlich das Salz übereinstimmen (kein Zeitstempel, Zufall etc)!?

[ToFaceTeKilla]

Zitat:

Zitat von gammatester (Beitrag 1206792)

Vielleicht solltest Du zuerst einmal klären, welche KDF die C#-Funktion PasswordDeriveBytes verwendet. Warum verwendest Du ausgerechnet PBKDF1, das als einzige Funktion eine Maximallänge (= Hashlänge) hat? Der Originalcode kann so nicht funktioniert haben mit 128-Bit-Hash und 256-Bit-Schlüssel.

PasswordDervieBytes benutzt PBKDF1. Zu dem Warum: Hat eine Kollegin gemacht, ich habe damit nix am Hut. Da die Funktion der des OP entspricht, tippe ich mal auf "irgendwo im Netz gefunden". Laut ihrer Aussage funktioniert das Ver- und Entschlüsseln auf C#-Seite. Vielleicht sollte man ja mal den C#-Code ändern...

Zitat:

Zitat von gammatester (Beitrag 1206792)

Bist Du sicher, daß beides mal die gleichen Eingangsdaten benutzt wurden? Insbesondere muß natürlich das Salz übereinstimmen (kein Zeitstempel, Zufall etc)!?

Die Eingangsdaten sind wirklich gleich. Feste Strings zum Testen.

Edit: Arg wie so oft sitzt das Problem vor dem Monitor :roll:

Delphi-Quellcode:

pbkdf1(hash,@Password[1], Length(password),@Salt[1],2,key,20);

statt

Delphi-Quellcode:

pbkdf1(hash,@Password[1], Length(password),@Salt,2,key,20);

ist des Rätsels Lösung. Der Salt-Parameter ist ja ein Pointer auf einen String. Naja, ich kann mich damit rausreden, dass ich mich bisher von Pointern fern gehalten habe, wenn es ging :stupid:
Jetzt funktioniert zumindest schon einmal das Ver- und Entschlüsseln auf Delphi-Seite. Mal schauen, ob es mit den C#-Testvektoren funktioniert.

[ToFaceTeKilla]

Wie zu erwarten war, geht es natürlich nicht so einfach.

Möglicherweise ist der C#-Code ja nicht mit DEC umkehrbar.
Deshalb wollte ich das jetzt mal mit deinem AES_CBC probieren, kriege da aber auch nur Zeichensalat raus.
Würdest du mir verraten, wie ich das implementieren muss?

Die Testvektoren sind:
Salt: Lovley
IV: 2013-02-14 15:45:07.307 (wenn ein AES-IV immer 16 Byte hat, heißt das, dass hier nur '2013-02-14 15:45' genommen wird?)
Base64-Ciphertext: d1n/OvzsX3r12qplF5izlg==
Plaintext: Test
Passwort (ASCII-Werte): 7 14 31 13

Mein Versuch sieht wie folgt aus (Base64-Decode ist aus DEC):

Delphi-Quellcode:

function DecryptBase64Str(const CipherText_Base64: Binary; const Password: Binary; const Salt: Binary; const InitVector: string): string;
var
  hash: PHashDesc;
  key: array[0..19] of byte;
  ctx: TAESContext;
  aesblck: TAESBlock;
  decodedTxt: string;
  i: Integer;
begin
  hash:= FindHash_by_ID(_SHA1);
  pbkdf1(hash,@Password[1], Length(password),@Salt[1],2,key,20);
  for i := 1 to 16 do
    aesblck[i-1]:= Byte(initvector[i]);
  decodedTxt:= TFormat_MIME64.Decode(CipherText_Base64);
  Result:= decodedTxt;
  ctx.IV:= aesblck;
  AES_CBC_Init_Decr(key,160,aesblck,ctx);
  AES_CBC_Decrypt(@decodedTxt[1],@result[1],length(decodedTxt),ctx);
end;

Über die kryptographische Sicherheit lässt sich sicherlich streiten, aber es geht ja erstmal darum, dass zum Laufen zu bekommen.

Edit:
Was mir noch einfällt: die C#-Verschlüsselung benutzt PKCS7 als Paddingmodus.

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1208155)

Delphi-Quellcode:

AES_CBC_Init_Decr(key,160,aesblck,ctx);

Das ist Unsinn! Es gibt keine 160-Bit AES-Schlüssel! Leider scheinst Du auch der Unsitte anzuhängen, Fehlercodes einfach nicht zu benutzen und auszuwerten. AES_CBC_Init_Decr ist eine function, mit Deinen Parametern liefert sie -1 = AES_Err_Invalid_Key_Size.

Wie schon gesagt, klär erst mal genau wie auch C#-Seite die Nicht-Standard-Operationen implementiert sind. Wenn das geklärt ist, reduziere alles auf Byte-Testvektoren. Also:

Passsword/Salt etc liefert letztendlich via pbkdf1 einen 128-, 192- or 256-Bit-Schlüssel, den man schon mal auf Übereinstimmung testen kann, ohne die Verschlüssung anzuwerfen. Wenn Du damit fertig bist, diesen Key als array[0..xx] of byte weiter verwenden.

Analog IV und Base64-decodierten Ciphertext CT mit PKCS7-Padding als Bytearrays.

Mit den drei Bytearrays Key, IV und CT gehst Du dann in die CBC-Entschlüsselung, der letzte Block des Klartexts enthält dann das Padding und kann für einen schnellen Test auf Übereinstimmung erstmal ignoriert werden. Ein Plaintext der Länge 4 ist nicht sinnvoll, weil CBC überhaupt nicht zum Einsatz kommt, nimm lieber einen mit 32 oder mehr Zeichen.

[ToFaceTeKilla]

Ja du hast ja recht. Asche über mein Haupt. Ich habe das in der Zwischenzeit beim durchsteppen auch gesehen, dass der Schlüssel nicht reicht.
Die 160 hatte ich ja wegen der Maximallänge von SHA-1 gewählt*. Ich habe gerade nochmal nachgeschlagen, wie das auf C#-Seite funktionieren kann und dabei ist mir aufgefallen, dass PasswordDeriveBytes.GetBytes einfach das Bytearray pseudozufällig auf die gewünschte Länge auffüllt (hier auch nochmal sehr schön beschrieben).
Dann muss wohl erstmal auf C#-Seite der Code angepasst werden.

*Man kann doch mit pbkdf1 und SHA-1 keinen Schlüssel > 160Bit erzeugen oder nicht? Deine pbkdf1-Funktion gibt dann ja auch kdf_err_invalid_dKLen zurück.

[gammatester]

Zitat:

Zitat von ToFaceTeKilla (Beitrag 1208184)

*Man kann doch mit pbkdf1 und SHA-1 keinen Schlüssel > 160Bit erzeugen oder nicht? Deine pbkdf1-Funktion gibt dann ja auch kdf_err_invalid_dKLen zurück.

Jedenfalls nicht mit einem Aufruf der Funktion. Wenn es denn sein muss, reichen zB zwei Aufrufe mit (..,salt1,..) plus (..,salt2,..) oder (..,salt,n1,..) plus (..,salt,n2,..).

Aber das ist Gefrickel. Wenn möglich, nimm lieber pbkdf2; damit kannst Du mit jeder Hashfunktion beliebig lange Bytefolgen erzeugen.

Edit: Sehe gerade das die API aus Deinem ersten Link als veraltet gekennzeichnet ist, die dort angegebene nicht veraltete Alternative ist GetBytes, das PBKDF2 benutzt.

[ToFaceTeKilla]

Soo da ich es jetzt hinbekommen habe, lasse ich die Allgemeinheit mal an der Lösung teilhaben:
Zum einen musste der C#-Code angepasst werden, da die KDF sich nicht standardkonform verhält:

Code:

public static string Encrypt(string PlainText, string Password, string InitialVector)
        {           
                        
            if (string.IsNullOrEmpty(PlainText))
                return "";

            byte[] InitialVectorBytes = new byte[16];
            Encoding.ASCII.GetBytes(InitialVector, 0, 16, InitialVectorBytes, 0);            
            byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt);            
            byte[] PlainTextBytes = Encoding.UTF8.GetBytes(PlainText);
            
            Rfc2898DeriveBytes DerivedPassword = new Rfc2898DeriveBytes(Password, SaltValueBytes, PasswordIterations);  //formals PasswordDeriveBytes
            byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8);            
            RijndaelManaged SymmetricKey = new RijndaelManaged();
            SymmetricKey.Mode = CipherMode.CBC;
            byte[] CipherTextBytes = null;

            using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes))
            {

                using (MemoryStream MemStream = new MemoryStream())
                {

                    using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write))
                    {
                        CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length);
                        CryptoStream.FlushFinalBlock();
                        CipherTextBytes = MemStream.ToArray();
                        MemStream.Close();
                        CryptoStream.Close();
                    }
                }
            }
            SymmetricKey.Clear();
            return Convert.ToBase64String(CipherTextBytes);
        }

Da wir einen hier einen Timestamp (z.B. 2013-03-13 11:10:04.500) als IV benutzen, nehmen wir nur die ersten 16 Bytes für den IV (InitialVectorBytes).

Und die Entschlüsselungs-Funktion in Delphi sieht dann so aus:

Delphi-Quellcode:

uses
  kdf, hash, sha1, aes_cbc, aes_type, DECFmt;

function DecryptBase64Str(const CipherText_Base64: Binary; const Password: Binary; const Salt: Binary; const InitVector: RawByteString): RawByteString;
var
  hash: PHashDesc;
  key: array[0..31] of byte;
  ctx: TAESContext;
  aesblck: TAESBlock;
  decodedTxt: RawByteString;
  i: Integer;
  lastByte: Byte;
  resLength: Integer;
  isPadded: Boolean;
begin
  hash:= FindHash_by_ID(_SHA1);
  pbkdf2(hash,@Password[1], Length(password),@Salt[1],Length(Salt),2,key,32);
  for i := 1 to 16 do
    aesblck[i-1]:= Byte(initvector[i]);
  decodedTxt:= TFormat_MIME64.Decode(CipherText_Base64);
  Result:= decodedTxt;
  ctx.IV:= aesblck;
  AES_CBC_Init_Decr(key,256,aesblck,ctx);
  AES_CBC_Decrypt(@decodedTxt[1],@result[1],length(decodedTxt),ctx);

  //PKCS#7-Padding umkehren
  resLength:= Length(Result);
  lastByte:= Byte(Result[resLength]);
  isPadded:= True;
  for i := resLength downto resLength-lastByte+1 do
    if Byte(Result[i]) = lastByte then
      Continue
    else
    begin
      isPadded:= False;
      Break;
    end;
  if isPadded then
    Result:= Copy(Result,1,resLength-lastByte);
end;

Credits gehen an gammatester für seine Geduld mit mir (Danke dafür) und natürlich für seine Crypto-Lib :thumb: