DEC 5.2 mit Vector deccipher Umbau von DOT net auf Delphi

[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 von ToFaceTeKilla:

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 von ToFaceTeKilla:

*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