C# nach Delphi aber keine Ahnung wie?

[DieDolly]

Der AESContext ist folgendermaßen deklariert

Delphi-Quellcode:

  TAESContext = packed record
                  RK      : TKeyArray;  {Key (encr. or decr.)   }
                  IV      : TAESBlock;  {IV or CTR              }
                  buf     : TAESBlock;  {Work buffer            }
                  bLen    : word;       {Bytes used in buf      }
                  Rounds  : word;       {Number of rounds       }
                  KeyBits : word;       {Number of bits in key  }
                  Decrypt : byte;       {<>0 if decrypting key  }
                  Flag    : byte;       {Bit 1: Short block     }
                  IncProc : TIncProc;   {Increment proc CTR-Mode}
                end;

Die KeySize (0x80) sind vermutlich 128. Aber was auch immer die BlockSize ist und das Padding, das gibt es bei den WE's glaube ich nicht.

[Zacherl]

function AES_CBC_Init_Decr(const Key; KeyBits: word; const IV: TAESBlock; var ctx: TAESContext): integer;

Hier musst du sowohl Key, KeyBits (= 128) und IV übergeben. Den Context solltest du meiner Meinung nach nicht per Hand modifizieren. BlockSize sollte normalerweise automatisch gleich der KeySize sein bei CBC. Müsstest du einfach mal probieren, ob was Sinnvolles als Resultat bei rauskommt.

Edit:
Auch wenn es egal sein sollte. Nimm bitte `TBytes` oder `TArray<Byte>` als Typ für Binärdaten anstelle von `RawByteString`.

Edit 2:
Die Rückgabe der AES Funktionen geben dir auch einen Fehlercode. Eventuell den mal prüfen, wenn im Output Buffer komplett gar nichts rauskommt.

[DieDolly]

Zitat:

Den Context solltest du meiner Meinung nach nicht per Hand modifizieren.

Das muss man scheinbar. Wenn wenn ich den IV im Context nicht setze, dann ist der übergebene Context leer.

Delphi-Quellcode:

 for i := 1 to 16 do
  aesblck[i - 1] := Byte(initVector[i]);

 ctx.IV := aesblck;
 AES_CBC_Init_Decr(initVector, 128, aesblck, ctx);
 AES_CBC_Decrypt(@EncryptedData[1], @Res[1], Length(EncryptedData), ctx);

Zitat:

Müsstest du einfach mal probieren, ob was Sinnvolles als Resultat bei rauskommt.

Bisher bekomme ich gar keins

[Zacherl]

Vergleiche mal deinen Aufruf:

Zitat von DieDolly:

AES_CBC_Init_Decr(initVector, 128, aesblck, ctx);

mit der Funktionsdefinition:
function AES_CBC_Init_Decr(const Key; KeyBits: word; const IV: TAESBlock; var ctx: TAESContext): integer;

Richtig wäre:
AES_CBC_Init_Decr(keyBytes, 128, aesblk, ctx);

[DieDolly]

Entweder bin ich zu dumm dafür oder Delphi kann das nichtm (was ich nicht glaube).

Delphi-Quellcode:

 AES_CBC_Init_Decr(keyBytes, 128, aesblck, ctx);
 SetLength(Res, 4096); // irgendeine große Nummer weil ich keine Ahnung habe wie groß das Ergebnis sein soll?
 AES_CBC_Decrypt(@EncryptedData[1], @Res[1], length(EncryptedData), ctx);

Ergebnis in einen TBytesStream schreiben, der dann von TZDecompressionStream auf die Festplatte geschrieben werden soll

Delphi-Quellcode:

 BytesStream := TBytesStream.Create;
 try
  BytesStream.Write(Res, Length(Res));

  ZLibStream := TZDecompressionStream.Create(BytesStream);
  try
   OutputStream := TFileStream.Create('dec.txt', fmCreate);
   try
    OutputStream.CopyFrom(ZLibStream, 0);
   finally
    OutputStream.Free;
   end;
  finally
   ZLibStream.Free;
  end;
 finally
  BytesStream.Free;
 end;

Die Ausgabe ist immer leer. Ich habe vorher Res auf die Platte schreiben lassen ohne irgendetwas zu dekomprimieren. Da ist auch tatsächlich was drin. Sieht im Prinzip genau so aus wie die Eingangsdaten. Das muss dann noch dekomprimiert werden woran ich scheitere leider.

Das hier ist mein letzter Versuch. Die zweite showmessage erzeugt schon einen data error. Jetzt gebe ich wohl oder übel auf.

Delphi-Quellcode:

 BytesStream := TBytesStream.Create(Res);
 try
  ShowMessage(BytesStream.Size.ToString);

  ZLibStream := TZDecompressionStream.Create(BytesStream);
  try
   ShowMessage(ZLibStream.Size.ToString);

   OutputStream := TFileStream.Create('dec.txt', fmCreate);
   try
    OutputStream.CopyFrom(ZLibStream, 0);
   finally
    OutputStream.Free;
   end;
  finally
   ZLibStream.Free;
  end;
 finally
  BytesStream.Free;
 end;

[Zacherl]

Dein BytesStream.Write(Res, Length(Res)) macht vermutlich Murks, weil du immer noch die RawByteStrings verwendest. Deren Indizierung beginnt bei 1 und nicht bei 0. Teste mal Res[1] . Bei dynamischen Arrays/Strings immer explizit den Index angeben, wenn du mit Zeigern arbeitest, sonst zeigt die Referenz nicht auf die Daten selbst, sondern das gemanagte Objekt.

[DieDolly]

 Res: TBytes; Hier mal alles

Kann das vielleicht daran liegen, weil ich Res auf Länge 4096 setze? Ich hab das einfach mal so groß gesetzt weil ich nicht weiß wieviel da rein muss.

Delphi-Quellcode:

procedure TFormMain.Button4Click(Sender: TObject);
const
 keyBytes: array [0 .. 31] of Byte = ($2A, $5F, $CB, $17, $91, 210, $2F, $B6, 2, $45, $B3, $D8, $36, $9E, $D0, $B2, $C2, $73, $71, $56, $3F, $BF, $1F, 60, $9E, $DF, $6B, $11, 130,
  90, $5D, 10);

var
 FS: TFileStream;
 Key, EncryptedData: TBytes;
 DecompressionStream, ZLibStream: TZDecompressionStream;
 OutputStream: TFileStream;
 ctx: TAESContext;
 aesblck: TAESBlock;
 i: Integer;
 Res: TBytes;
 BytesStream: TBytesStream;
 MemoryStream: TMemoryStream;

var
 fileContent, initVector: TArray<Byte>;
begin
 {*
  fileContent := TFile.ReadAllBytes('enc.txt');
  SetLength(EncryptedData, length(fileContent) - $38);
  SetLength(initVector, $10);
  TArray.Copy<Byte>(fileContent, EncryptedData, $38, 0, length(EncryptedData));
  TArray.Copy<Byte>(fileContent, initVector, $24, 0, $10);

  for i := 1 to 16 do
  aesblck[i - 1] := Byte(initVector[i]);
  ctx.IV := aesblck;
  AES_CBC_Init_Decr(keyBytes, 128, aesblck, ctx);
  SetLength(Res, 4096);
  AES_CBC_Decrypt(@EncryptedData[1], @Res[1], length(EncryptedData), ctx);

  Exit;
  *}

 FS := TFileStream.Create('enc.txt', fmOpenRead);
 try
  FS.Seek($24, soBeginning);
  SetLength(Key, 16);
  FS.Read(Key[0], length(Key));

  FS.Seek($38, soBeginning);
  SetLength(EncryptedData, FS.Size - $38);
  FS.Read(EncryptedData[0], length(EncryptedData));

  for i := 1 to 16 do
   aesblck[i - 1] := Byte(Key[i]);
  ctx.IV := aesblck;
  AES_CBC_Init_Decr(keyBytes, 128, aesblck, ctx);
  SetLength(Res, 4096);
  AES_CBC_Decrypt(@EncryptedData[1], @Res[1], length(EncryptedData), ctx);
 finally
  FS.Free;
 end;
 // Die Resultate beider Codeblöcke (oben der kommentierte und der danach) sind gleich

 BytesStream := TBytesStream.Create(Res);
 try
  ShowMessage(BytesStream.Size.ToString);

  ZLibStream := TZDecompressionStream.Create(BytesStream);
  try
   ShowMessage(ZLibStream.Size.ToString);

   OutputStream := TFileStream.Create('dec.txt', fmCreate);
   try
    OutputStream.CopyFrom(ZLibStream, 0);
   finally
    OutputStream.Free;
   end;
  finally
   ZLibStream.Free;
  end;
 finally
  BytesStream.Free;
 end;

end;

Hier etwas sauberer und die Ausgabedatei ist trotzdem 0 byte groß. Das Problem scheint TZDecompressionStream zu sein. Oder meine 4096 feste Arraygröße.
Aber selbst wenn ich Res auf FS.Size setze ist die Ausgabedatei leer.

Delphi-Quellcode:

 MemoryStream := TMemoryStream.Create;
 try
  MemoryStream.Write(Res[1], Length(Res));

  ZLibStream := TZDecompressionStream.Create(MemoryStream);
  try
   OutputStream := TFileStream.Create('dec.txt', fmCreate);
   try
    OutputStream.CopyFrom(ZLibStream, 0);
   finally
    OutputStream.Free;
   end;
  finally
   ZLibStream.Free;
  end;
 finally
  MemoryStream.Free;
 end;

[Zacherl]

Wenn du jetzt TBytes verwendest, muss hier AES_CBC_Decrypt(@EncryptedData[1], @Res[1], length(EncryptedData), ctx); auf jeden Fall der Index schonmal jetzt 0 sein - sowohl bei EncryptedData , als auch bei Res .

Die Zuweisung ctx.IV := aesblck ist überflüssig.

An dieser Stelle steht nicht der Key, sondern der IV!

Delphi-Quellcode:

FS.Seek($24, soBeginning);
SetLength(Key, 16);
FS.Read(Key[0], length(Key));

Auch würde ich Res definitiv nicht hardcoded auf 4096 Bytes festlegen. Vorher hattest du doch bereits einmal korrekt die Länge mit FS.Size - $38 festgelegt. Wenn am Ende noch zufällige Daten stehen kann hier auch später die Dekompression evtl. fehlschlagen.

Wenn es danach immer noch nicht klappt, kann es natürlich durchaus sein, dass das Entschlüsseln bereits fehlschlägt (es werden zwar Daten entschlüsselt, aber ob die Blöcke später korrekt sind weißt du nicht - könnte man aber prüfen, indem man dem C# Programm beibringt mal einen Zwischenstand zu printen).

[Zacherl]

Kannst du mal deine Testdatei hochladen?

[DieDolly]

Ich bekomme jetzt zwar eine Ausgabe aber die sieht in etwa so aus

Code:

¶•tø–ÙØçèØ¡ŠœÀ!xéâ¬*†W³`Y�´ÞÎüX™©é¾NÞ–ˆÕ*ºµàrC¶'bJTE�Â

usw.

Das Ur-alt-Originalprogramm ist übrigens in Delphi geschrieben. Dummerweise wurde das Repo gelöscht!
Die Exe habe ich noch.

Eine sekunde bitte ich muss mir gerade die Edits durchlesen.

Zitat:

An dieser Stelle steht nicht der Key, sondern der IV!

In "Key" stand der IV drin. Nur der Variablenname ist falsch.

- Anhang gelöscht