Pak6 encryption support

Generators/GBX.NET.Generators/ChunkL/MemberSerializationWriter.cs

@@ -272,12 +272,20 @@ private void AppendRead(int indent, ChunkProperty chunkProperty)
 
         sb.AppendIndent(indent);
 
-        if (!self && !isUnknown)
+        if (chunkProperty.Type.PrimaryType is "version" or "versionb")
         {
-            sb.Append("n.");
+            sb.Append("Version");
+        }
+        else
+        {
+            if (!self && !isUnknown)
+            {
+                sb.Append("n.");
+            }
+
+            sb.Append(name);
         }
 
-        sb.Append(name);
         sb.Append(" = ");
 
         if (chunkProperty is ChunkEnum chunkEnum)
@@ -289,6 +297,18 @@ private void AppendRead(int indent, ChunkProperty chunkProperty)
 
         sb.Append("r.Read");
 
+        if (chunkProperty.Type.PrimaryType == "version")
+        {
+            sb.Append("Int32();");
+            return;
+        }
+
+        if (chunkProperty.Type.PrimaryType == "versionb")
+        {
+            sb.Append("Byte();");
+            return;
+        }
+
         if (chunkProperty.Type.IsArray)
         {
             sb.Append("Array");

Src/GBX.NET.PAK/Blowfish.cs

@@ -31,7 +31,7 @@ namespace GBX.NET.PAK;
 /// </summary>
 internal sealed class Blowfish
 {
-    private const int N = 16;
+    private int N = 16;
 
     private readonly uint[] P = [
         0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
@@ -226,7 +226,7 @@ internal sealed class Blowfish
     /// Constructs and initializes a blowfish instance with the supplied key.
     /// </summary>
     /// <param name="key">The key to cipher with.</param>
-    public Blowfish(byte[] key)
+    public Blowfish(byte[] key, bool isPak18 = false)
     {
         short i;
         short j;
@@ -235,6 +235,12 @@ public Blowfish(byte[] key)
         uint datal;
         uint datar;
 
+        // Trick #1: reduce N from 16 to 8
+        if (isPak18)
+        {
+            N = 8;
+        }
+
         j = 0;
         for (i = 0; i < N + 2; ++i)
         {
@@ -271,6 +277,16 @@ public Blowfish(byte[] key)
                 S[i, j + 1] = datar;
             }
         }
+
+        // Trick #2: reverse the order of first 10 elements in the P array
+        if (isPak18)
+        {
+            uint[] temp = (uint[])P.Clone();
+            for (i = 0; i < 10; i++)
+            {
+                P[i] = temp[9 - i];
+            }
+        }
     }
 
     /// <summary>
@@ -300,6 +316,53 @@ private uint F(uint x)
         return y;
     }
 
+    /// <summary>
+    /// Encrypts a byte array in place.
+    /// </summary>
+    /// <param name="data">The array to encrypt.</param>
+    /// <param name="length">The amount to encrypt.</param>
+    public void Encipher(byte[] data)
+    {
+        if (data.Length % 8 != 0)
+        {
+            throw new Exception("Invalid Length");
+        }
+
+        for (int i = 0; i < data.Length; i += 8)
+        {
+            // Encode the data in 8 byte blocks.
+            var xl = BitConverter.ToUInt32(data, i);
+            var xr = BitConverter.ToUInt32(data, i + 4);
+            Encipher(ref xl, ref xr);
+            Array.Copy(BitConverter.GetBytes(xl), 0, data, i, 4);
+            Array.Copy(BitConverter.GetBytes(xr), 0, data, i + 4, 4);
+        }
+    }
+
+#if NET5_0_OR_GREATER
+    /// <summary>
+    /// Encrypts a byte span in place.
+    /// </summary>
+    /// <param name="data">The array to encrypt.</param>
+    /// <param name="length">The amount to encrypt.</param>
+    public void Encipher(Span<byte> data)
+    {
+        if (data.Length % 8 != 0)
+        {
+            throw new Exception("Invalid Length");
+        }
+
+        for (int i = 0; i < data.Length; i += 8)
+        {
+            // Encode the data in 8 byte blocks.
+            var xl = BitConverter.ToUInt32(data.Slice(i));
+            var xr = BitConverter.ToUInt32(data.Slice(i + 4));
+            Encipher(ref xl, ref xr);
+            BitConverter.TryWriteBytes(data.Slice(i), xl);
+            BitConverter.TryWriteBytes(data.Slice(i + 4), xr);
+        }
+    }
+#endif
 
     /// <summary>
     /// Encrypts 8 bytes of data (1 block)
@@ -393,7 +456,7 @@ private void Decipher(ref uint xl, ref uint xr)
         uint Xl;
         uint Xr;
         uint temp;
-        short i;
+        int i;
 
         Xl = xl;
         Xr = xr;

Src/GBX.NET.PAK/BlowfishStream.cs

@@ -14,13 +14,15 @@ public class BlowfishStream : Stream, IEncryptionInitializer
 #endif
     private int bufferIndex;
     private int totalIndex;
+    private bool isPak18;
 
-    public BlowfishStream(Stream stream, byte[] key, ulong iv)
+    public BlowfishStream(Stream stream, byte[] key, ulong iv, bool isPak18 = false)
     {
         this.stream = stream ?? throw new ArgumentNullException(nameof(BlowfishStream.stream));
-        blowfish = new Blowfish(key);
+        blowfish = new Blowfish(key, isPak18);
         this.iv = iv;
         memoryBuffer = new byte[8];
+        this.isPak18 = isPak18;
     }
 
     public override bool CanRead => stream.CanRead;
@@ -75,19 +77,48 @@ public override int Read(byte[] buffer, int offset, int count)
 #if NET5_0_OR_GREATER
                 var read = stream.Read(memorySpan);
                 var nextIV = BitConverter.ToUInt64(memorySpan);
-                blowfish.Decipher(memorySpan);
+
+                // Trick #3: Switch Decipher with Encipher
+                if(isPak18)
+                {
+                    blowfish.Encipher(memorySpan);
+                }
+                else
+                {
+                    blowfish.Decipher(memorySpan);
+                }
+
                 var block = BitConverter.ToUInt64(memorySpan);
                 block ^= iv;
                 BitConverter.TryWriteBytes(memorySpan, block);
 #else
                 var read = stream.Read(memoryBuffer, 0, 8);
                 ulong nextIV = BitConverter.ToUInt64(memoryBuffer, 0);
-                blowfish.Decipher(memoryBuffer);
+
+                // Trick #3: Switch Decipher with Encipher
+                if(isPak18)
+                {
+                    blowfish.Encipher(memoryBuffer);
+                }
+                else
+                {
+                    blowfish.Decipher(memoryBuffer);
+                }
+
                 ulong block = BitConverter.ToUInt64(memoryBuffer, 0);
                 block ^= iv;
                 memoryBuffer = BitConverter.GetBytes(block);
 #endif
-                iv = nextIV;
+
+                // Trick #4: Custom nextIV logic
+                if (isPak18)
+                {
+                    iv = iv >> 0x2f ^ iv * 9 ^ nextIV;
+                }
+                else
+                {
+                    iv = nextIV;
+                }
             }
 #if NET5_0_OR_GREATER
             buffer[offset + i] = memorySpan[bufferIndex % 8];

Src/GBX.NET.PAK/GBX.NET.PAK.csproj

@@ -32,6 +32,7 @@
 
         <GenerateDocumentationFile>false</GenerateDocumentationFile>
         <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
     <ItemGroup>