Ich habe hier C# Code den ich gerne nach Delphi portieren möchte aber ich verstehe speziell die Array-Sachen nicht.
Könnt ihr mir helfen? Alles was unwichtig ist habe ich rausgenommen. Ist das in Delphi überhaupt möglich? Als Entschlüsselungsmechanik würde ich Wolfgang Erhardts Bibliothek nutzen.

markieren

Code:

byte[] bytes = LoadFileToMemory(file_to_load);

byte[] buffer = new byte[bytes.Length - 0x38];

byte[] keyBytes = new byte[] {
    0x2a, 0x5f, 0xcb, 0x17, 0x91, 210, 0x2f, 0xb6, 2, 0x45, 0xb3, 0xd8, 0x36, 0x9e, 0xd0, 0xb2,
    0xc2, 0x73, 0x71, 0x56, 0x3f, 0xbf, 0x1f, 60, 0x9e, 0xdf, 0x6b, 0x11, 130, 90, 0x5d, 10
    };

byte[] destinationArray = new byte[0x10];

Array.Copy(bytes, 0x38, buffer, 0, buffer.Length);
Array.Copy(bytes, 0x24, destinationArray, 0, destinationArray.Length);

byte[] bytebuffer = AESDecrypt(buffer, keyBytes, destinationArray);
string input = "";

using (MemoryStream stream = new MemoryStream(bytebuffer))
{
    using (InflaterInputStream stream2 = new InflaterInputStream(stream))
    {
        using (StreamReader reader = new StreamReader(stream2))
        {
            input = reader.ReadToEnd();
        }
    }
}


private static byte[] AESDecrypt(byte[] _encryptedData, byte[] _keyBytes, byte[] _iv)
{
    RijndaelManaged managed = new RijndaelManaged
    {
        Mode = CipherMode.CBC,
        Padding = PaddingMode.None,
        IV = _iv,
        KeySize = 0x80,
        BlockSize = 0x80,
        Key = _keyBytes
    };
    return managed.CreateDecryptor().TransformFinalBlock(_encryptedData, 0, _encryptedData.Length);
}

So eine Datei kann beispielsweise so aussehen (nur ein Teilausschnitt)

markieren

Code:

5363 7343 fe11 7934 9f07 6068 ad49 bd21
0dd4 16a5 3c76 c189 9860 6f90 19b3 85d0
3603 ee3a 1f22 7c57 eb4d 71f0 c369 cca8

Ich würde vorschlagen den C# Code weitestgehendes zu vergessen und nur die Funktionalität zu reproduzieren. Sprich:

1. Datei in einen Stream (anstelle des `buffer` Arrays) laden
2. An Stelle 0x24 den AES-IV mit einer Länge von 0x10 (16) Bytes auslesen
3. Den Dateiheader(?) ansonsten ignorieren und mit Stream.Seek zu Offset 0x38 springen
4. Die restlichen im Stream befindlichen Daten entschlüsseln:
   • AES (CBC, ohne Padding)
   • IV = die 16 ausgelesenen Bytes von Offset 0x24
   • Keysize = 0x80 Bytes
   • Blocksize = 0x80 Bytes
5. Die entschlüsselten Daten mit "Deflate" dekomprimieren

Wenn Wolfgang Erhardts Lib die genannten AES Parameter unterstützt, solltest du diese verwenden können. `InflateInputStream` gehört meiner Recherche nach zu ZLib. Dafür gibt es in Delphi auch eine Lib.

Ganz ehrlich? Schon bei Punkt 2 kann ich aussteigen

Habe grade kein Delphi hier, aber grob aus dem Kopf:

zusammenfalten · markieren

Delphi-Quellcode:

var
  FS: TFileStream;
  Key: TBytes;
begin
  FS := TFileStream.Create('...', fmOpenRead);
  try
    FS.Seek($24, soBeginning);
    SetLength(Key, 16);
    FS.Read(Key[0], Length(Key));
    // ...
  finally
    FS.Free;
  end;

Zur Dekompression:

markieren

Delphi-Quellcode:

ZLibStream := TZDecompressionStream.Create(FS);
OutputStream.CopyFrom(ZLibStream, 0);

OutputStream kann z.B. auch ein TFileStream , welcher die unkomprimierten Daten direkt auf der Platte ablegt.

Der Ehrlichkeit halber hier mal erbärmlicher Versuch von vorher. Mehr als da ist bei mir nicht drin
iv := MemoryStream.Read(iv^, 36, 16); Nur damit ich das richtig verstehe. Ist der IV der Schlüssel zum Entschlüsseln?

Nee, der Schlüssel befindet sich in dem keyBytes Array aus deinem Beispiel. Der IV ist der Initialisierungsvektor für den AES-Cipher (verwendet man analog zu einem Salt, damit gleiche Daten selbst bei gleichem Schlüssel nicht den gleichen Cyphertext generieren). Man benötigt beides, um die Daten zu entschlüsseln.

Ach so. Wie würdest du die Keybytes denn deklarieren? Ich würde jetzt alles nach Dezimal umrechnen und daraus ein Array bauen.
Oder eben so

markieren

Delphi-Quellcode:

 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);

Ach herr je das wird mir zu kompliziert. Das mit den von Position 24 und 0x10 verstehe ich ja schon nicht weil ich den Originalcode eben nicht verstehe.
Wenn ich der Logik aber folge, dann übergebe ich dem AES-Decrypt den Stream von Position (0x38 bis (Streamlänge minus 0x38))
Ungefähr so

markieren

Delphi-Quellcode:

  StreamToEncrypt.CopyFrom(FS, FS.Size - $38); // Den FileStream vom Anfang bis Ende minus $38
  StreamToEncrypt.Position := $38; // An Position $38 gehen (die ersten und letzten $38 sind scheinbar unwichtig). Gibt aber einen stream-Schreibfehler als Fehlermeldung

Im Original sieht das so aus

markieren

Code:

byte[] buffer = new byte[bytes.Length - 0x38]; // ignoriere die letzten $38

Array.Copy(bytes, 0x38, buffer, 0, buffer.Length); // ignoriere auch die ersten $38 und kopiere alles von >38 und <ende-38

Aber AES verstehe ich noch viel weniger. Was da an parametern verlangt wird
So weit bin ich aber weiter geht wirklich nicht

zusammenfalten · markieren

Delphi-Quellcode:

var
 ctx: TAESContext;
 aesblck: TAESBlock;
 i: Integer;
begin
  for i := 1 to 16 do
   aesblck[i - 1] := byte(Key[i]);

  ctx.IV := aesblck;
  AES_CBC_Init_Decr(Key, 256, aesblck, ctx); // warum 256 ?!
  AES_CBC_Decrypt(xyz, xyz, Length(xyz), ctx);

Das ist doch gar nicht so schwer mit der Position.

Es gibt da eine Folge von Bytes (Stream) und ab der Position 24hex kommen 10hex Bytes und die repräsentieren den Initialisierungs-Vektor.

Und ab der Position 38hex fangen die echten Daten an.

markieren

Delphi-Quellcode:

var
  file_to_load: string;
  bytes, destinationArray, buffer: TArray<byte>;
begin
  bytes := TFile.ReadAllBytes(file_to_load);
  SetLength(buffer,Length(bytes)-$38);
  SetLength(destinationArray,$10);
  TArray.Copy<Byte>(bytes,buffer,$38,0,Length(buffer));
  TArray.Copy<Byte>(bytes,destinationArray,$24,0,$10);
end;

Aufbauend auf beider eurer Beispiel habe ich das hier erweitert.

zusammenfalten · markieren

Delphi-Quellcode:

var
 ctx: TAESContext;
 aesblck: TAESBlock;
 i: Integer;
 Res: RawByteString;
begin
 // Das ist scheinbar notwendig ( https://www.delphipraxis.net/1208740-post21.html )
 for i := 1 to 16 do
  aesblck[i - 1] := Byte(initVector[i]);

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

Irgendwas mache ich aber noch falsch denn Res ist 0 Zeichen lang.

Im original gibt es eine Key- und BlockSize sowie Padding. Was auch immer die bedeuten.

Zitat von DieDolly:

Im original gibt es eine Key- und BlockSize sowie Padding. Was auch immer die bedeuten.

Die befinden sich evtl. auch im Context? Ich kenne die Lib von Wolfgang Erhardt leider nicht.