From fe7cd3f3788a6800cb86e8f6970d173a900726d4 Mon Sep 17 00:00:00 2001
From: GoogleBen <william.ben.wyatt@gmail.com>
Date: Thu, 10 Mar 2022 03:49:52 -0600
Subject: [PATCH] Begin Elden Ring support

---
 BinderTool.Core/Bdt5/Bdt5FileStream.cs  |  14 +++-
 BinderTool.Core/Bdt5/Bdt5InnerStream.cs | 102 ++++++++++++++++++++++++
 BinderTool.Core/Bhd5/Bhd5BucketEntry.cs |  24 +++---
 BinderTool.Core/BinderTool.Core.csproj  |   1 +
 BinderTool.Core/Bnd4/Bnd4File.cs        |   8 +-
 BinderTool.Core/CryptographyUtility.cs  |  65 ++++++++-------
 BinderTool.Core/Enc/EncFile.cs          |   2 +-
 BinderTool.Core/GameVersion.cs          |   3 +-
 BinderTool.Core/Sl2/Sl2UserData.cs      |   6 +-
 BinderTool/BinderTool.csproj            |   5 ++
 BinderTool/DecryptionKeys.cs            |  80 ++++++++++++++++++-
 BinderTool/DictionaryER.csv             |   1 +
 BinderTool/FileNameDictionary.cs        |   1 +
 BinderTool/Options.cs                   |   6 +-
 BinderTool/Program.cs                   |  54 +++++++++----
 15 files changed, 299 insertions(+), 73 deletions(-)
 create mode 100644 BinderTool.Core/Bdt5/Bdt5InnerStream.cs
 create mode 100644 BinderTool/DictionaryER.csv

diff --git a/BinderTool.Core/Bdt5/Bdt5FileStream.cs b/BinderTool.Core/Bdt5/Bdt5FileStream.cs
index c65cb66..b02c824 100644
--- a/BinderTool.Core/Bdt5/Bdt5FileStream.cs
+++ b/BinderTool.Core/Bdt5/Bdt5FileStream.cs
@@ -12,15 +12,21 @@ public Bdt5FileStream(Stream inputStream)
             _inputStream = inputStream;
         }
 
-        public MemoryStream Read(long fileOffset, long fileSize)
+        public Stream Read(long fileOffset, long fileSize)
         {
             if (fileOffset + fileSize > _inputStream.Length)
                 throw new EndOfStreamException();
             _inputStream.Seek(fileOffset, SeekOrigin.Begin);
 
-            byte[] buffer = new byte[fileSize];
-            _inputStream.Read(buffer, 0, (int) fileSize);
-            return new MemoryStream(buffer);
+            if (fileSize < Bdt5InnerStream.MAX_STREAM_LEN)
+            {
+                byte[] buffer = new byte[fileSize];
+                _inputStream.Read(buffer, 0, (int)fileSize);
+                return new MemoryStream(buffer);
+            }
+            var ans = new Bdt5InnerStream(_inputStream, fileSize);
+            _inputStream.Seek(fileSize, SeekOrigin.Current);
+            return ans;
         }
 
         public static Bdt5FileStream OpenFile(string path, FileMode mode, FileAccess access)
diff --git a/BinderTool.Core/Bdt5/Bdt5InnerStream.cs b/BinderTool.Core/Bdt5/Bdt5InnerStream.cs
new file mode 100644
index 0000000..5919979
--- /dev/null
+++ b/BinderTool.Core/Bdt5/Bdt5InnerStream.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+
+namespace BinderTool.Core.Bdt5
+{
+    public class Bdt5InnerStream : Stream
+    {
+        public const int MAX_STREAM_LEN = 1_000_000;
+
+        private List<MemoryStream> streams;
+
+        private long length;
+
+
+        public override long Length => length;
+
+        public override long Position { get; set; }
+
+        public override bool CanRead => true;
+
+        public override bool CanSeek => true;
+
+        public override bool CanWrite => true;
+
+        public Bdt5InnerStream(Stream from, long length, long offset)
+        {
+            this.length = length;
+            this.streams = new List<MemoryStream>();
+            long startPos = from.Position;
+            for (long pos = 0; pos < length; pos += MAX_STREAM_LEN)
+            {
+                byte[] buf = new byte[MAX_STREAM_LEN];
+                from.Seek(offset + pos, SeekOrigin.Begin);
+                from.Read(buf, 0, (int)Math.Min(length - pos, MAX_STREAM_LEN));
+                streams.Add(new MemoryStream(buf));
+            }
+            from.Seek(startPos, SeekOrigin.Begin);
+        }
+        public Bdt5InnerStream(Stream from, long length) : this(from, length, 0) {}
+        public Bdt5InnerStream(long length)
+        {
+            this.length = length;
+            this.streams = new List<MemoryStream>();
+            for (long pos = 0; pos < length; pos += MAX_STREAM_LEN)
+            {
+                byte[] buf = new byte[MAX_STREAM_LEN];
+                streams.Add(new MemoryStream(buf));
+            }
+        }
+
+        public override void Flush() {}
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (this.Position >= this.length) return 0;
+            long startPos = this.Position;
+            long end = Math.Min(this.Position + count, this.length);
+            while (this.Position < end)
+            {
+                var s = this.streams[(int)(this.Position / MAX_STREAM_LEN)];
+                s.Seek(this.Position % MAX_STREAM_LEN, SeekOrigin.Begin);
+                var read = s.Read(buffer, offset, count);
+                this.Position += read;
+                offset += read;
+                count -= read;
+            }
+            return (int)(end - startPos);
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            if (origin == SeekOrigin.Begin) this.Position = offset;
+            if (origin == SeekOrigin.Current) this.Position += offset;
+            if (origin == SeekOrigin.End) this.Position = this.length + offset;
+            return this.Position;
+        }
+
+        public override void SetLength(long value)
+        {
+            this.length = value;
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            long end = this.Position + count;
+            while (this.Position < end)
+            {
+                var s = this.streams[(int)(this.Position / MAX_STREAM_LEN)];
+                s.Seek(this.Position % MAX_STREAM_LEN, SeekOrigin.Begin);
+                var toWrite = (int)Math.Min(s.Length - s.Position, count);
+                s.Write(buffer, offset, toWrite);
+                this.Position += toWrite;
+                offset += toWrite;
+                count -= toWrite;
+            }
+        }
+    }
+}
diff --git a/BinderTool.Core/Bhd5/Bhd5BucketEntry.cs b/BinderTool.Core/Bhd5/Bhd5BucketEntry.cs
index 82982bc..cd6e23d 100644
--- a/BinderTool.Core/Bhd5/Bhd5BucketEntry.cs
+++ b/BinderTool.Core/Bhd5/Bhd5BucketEntry.cs
@@ -1,10 +1,11 @@
-using System.IO;
+using System;
+using System.IO;
 
 namespace BinderTool.Core.Bhd5
 {
     public class Bhd5BucketEntry
     {
-        public uint FileNameHash { get; private set; }
+        public ulong FileNameHash { get; private set; }
         public long FileSize { get; set; }
         public long PaddedFileSize { get; set; }
         public long FileOffset { get; private set; }
@@ -15,22 +16,19 @@ public class Bhd5BucketEntry
         public static Bhd5BucketEntry Read(BinaryReader reader, GameVersion version)
         {
             Bhd5BucketEntry result = new Bhd5BucketEntry();
-            result.FileNameHash = reader.ReadUInt32();
+            result.FileNameHash = reader.ReadUInt64();
             result.PaddedFileSize = reader.ReadUInt32();
+            result.FileSize = reader.ReadUInt32();
+            if (result.FileSize != 0)
+            {
+                //Console.WriteLine("FS not 0");
+            }
             result.FileOffset = reader.ReadInt64();
+
             long saltedHashOffset = reader.ReadInt64();
             long aesKeyOffset = reader.ReadInt64();
 
-            switch (version)
-            {
-                case GameVersion.DarkSouls3:
-                case GameVersion.Sekiro:
-                    result.FileSize = reader.ReadInt64();
-                    break;
-                default:
-                    result.FileSize = result.PaddedFileSize;
-                    break;
-            }
+            
 
             if (saltedHashOffset != 0)
             {
diff --git a/BinderTool.Core/BinderTool.Core.csproj b/BinderTool.Core/BinderTool.Core.csproj
index 0978a42..3993ca9 100644
--- a/BinderTool.Core/BinderTool.Core.csproj
+++ b/BinderTool.Core/BinderTool.Core.csproj
@@ -75,6 +75,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Bdf4\Bdf4FileStream.cs" />
+    <Compile Include="Bdt5\Bdt5InnerStream.cs" />
     <Compile Include="Bhd5\Bhd5Range.cs" />
     <Compile Include="Bdt5\Bdt5FileStream.cs" />
     <Compile Include="Bhd5\Bhd5AesKey.cs" />
diff --git a/BinderTool.Core/Bnd4/Bnd4File.cs b/BinderTool.Core/Bnd4/Bnd4File.cs
index c8aeff1..2bbb088 100644
--- a/BinderTool.Core/Bnd4/Bnd4File.cs
+++ b/BinderTool.Core/Bnd4/Bnd4File.cs
@@ -83,9 +83,13 @@ private void Read(Stream inputStream)
                     reader.Seek(fileNameOffset);
                     fileName = reader.ReadNullTerminatedString();
                 }
+                if (fileName.Contains("param")) Console.WriteLine($"{fileName} {fileEntrySize} {fileEntryOffset}");
 
-                reader.Seek(fileEntryOffset);
-                _entries.Add(Bnd4FileEntry.Read(inputStream, fileEntrySize, fileName));
+                if (fileName.Length > 0 && fileEntrySize > 0 && fileEntryOffset > 0)
+                {
+                    reader.Seek(fileEntryOffset);
+                    _entries.Add(Bnd4FileEntry.Read(inputStream, fileEntrySize, fileName));
+                }
                 reader.Seek(position);
             }
         }
diff --git a/BinderTool.Core/CryptographyUtility.cs b/BinderTool.Core/CryptographyUtility.cs
index 98e2fed..fb8c8ee 100644
--- a/BinderTool.Core/CryptographyUtility.cs
+++ b/BinderTool.Core/CryptographyUtility.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using BinderTool.Core.Bdt5;
 using BinderTool.Core.Bhd5;
 using Org.BouncyCastle.Crypto;
 using Org.BouncyCastle.Crypto.Engines;
@@ -11,62 +12,65 @@ namespace BinderTool.Core
 {
     public static class CryptographyUtility
     {
-        public static MemoryStream DecryptAesEcb(Stream inputStream, byte[] key)
+        public static Stream DecryptAesEcb(Stream inputStream, byte[] key)
         {
             var cipher = CreateAesEcbCipher(key);
             return DecryptAes(inputStream, cipher, inputStream.Length);
         }
 
-        public static MemoryStream DecryptAesCbc(Stream inputStream, byte[] key, byte[] iv)
+        public static Stream DecryptAesCbc(Stream inputStream, byte[] key, byte[] iv)
         {
-            AesEngine engine = new AesEngine();
+            var engine = new CbcBlockCipher(new AesEngine());
             KeyParameter keyParameter = new KeyParameter(key);
             ICipherParameters parameters = new ParametersWithIV(keyParameter, iv);
 
-            BufferedBlockCipher cipher = new BufferedBlockCipher(new CbcBlockCipher(engine));
-            cipher.Init(false, parameters);
-            return DecryptAes(inputStream, cipher, inputStream.Length);
+            engine.Init(false, parameters);
+            return DecryptAes(inputStream, engine, inputStream.Length);
         }
 
-        public static MemoryStream DecryptAesCtr(Stream inputStream, byte[] key, byte[] iv)
+        public static Stream DecryptAesCtr(Stream inputStream, byte[] key, byte[] iv)
         {
-            AesEngine engine = new AesEngine();
+            SicBlockCipher engine = new SicBlockCipher(new AesEngine());
             KeyParameter keyParameter = new KeyParameter(key);
             ICipherParameters parameters = new ParametersWithIV(keyParameter, iv);
 
-            BufferedBlockCipher cipher = new BufferedBlockCipher(new SicBlockCipher(engine));
-            cipher.Init(false, parameters);
-            return DecryptAes(inputStream, cipher, inputStream.Length);
+            engine.Init(false, parameters);
+            return DecryptAes(inputStream, engine, inputStream.Length);
         }
 
-        private static BufferedBlockCipher CreateAesEcbCipher(byte[] key)
+        private static IBlockCipher CreateAesEcbCipher(byte[] key)
         {
             AesEngine engine = new AesEngine();
             KeyParameter parameter = new KeyParameter(key);
-            BufferedBlockCipher cipher = new BufferedBlockCipher(engine);
-            cipher.Init(false, parameter);
-            return cipher;
+            engine.Init(false, parameter);
+            return engine;
         }
 
-        private static MemoryStream DecryptAes(Stream inputStream, BufferedBlockCipher cipher, long length)
+        private static Stream DecryptAes(Stream inputStream, IBlockCipher cipher, long length)
         {
             int blockSize = cipher.GetBlockSize();
-            int inputLength = (int)length;
-            int paddedLength = inputLength;
+            long inputLength = length;
+            long paddedLength = inputLength;
             if (paddedLength % blockSize > 0)
             {
                 paddedLength += blockSize - paddedLength % blockSize;
             }
 
-            byte[] input = new byte[paddedLength];
-            byte[] output = new byte[cipher.GetOutputSize(paddedLength)];
+            byte[] input = new byte[blockSize];
+            byte[] output = new byte[blockSize];
+            var outputStream = new Bdt5.Bdt5InnerStream(paddedLength);
 
-            inputStream.Read(input, 0, inputLength);
-            int len = cipher.ProcessBytes(input, 0, input.Length, output, 0);
-            cipher.DoFinal(output, len);
+            for (long pos = 0; pos < inputLength; pos += blockSize)
+            {
+                int read = inputStream.Read(input, 0, blockSize);
+                if (read < blockSize)
+                {
+                    for (int i = read; i < blockSize; i++) input[i] = 0;
+                }
+                cipher.ProcessBlock(input, 0, output, 0);
+                outputStream.Write(output, 0, blockSize);
+            }
 
-            MemoryStream outputStream = new MemoryStream();
-            outputStream.Write(output, 0, inputLength);
             outputStream.Seek(0, SeekOrigin.Begin);
             return outputStream;
         }
@@ -135,7 +139,7 @@ public static AsymmetricKeyParameter GetKeyOrDefault(string key)
             }
         }
 
-        public static void DecryptAesEcb(MemoryStream inputStream, byte[] key, Bhd5Range[] ranges)
+        public static void DecryptAesEcb(Stream inputStream, byte[] key, Bhd5Range[] ranges)
         {
             var cipher = CreateAesEcbCipher(key);
 
@@ -148,9 +152,14 @@ public static void DecryptAesEcb(MemoryStream inputStream, byte[] key, Bhd5Range
 
                 inputStream.Position = range.StartOffset;
                 long length = range.EndOffset - range.StartOffset;
-                MemoryStream decryptedStream = DecryptAes(inputStream, cipher, length);
+                Stream decryptedStream = DecryptAes(inputStream, cipher, length);
                 inputStream.Position = range.StartOffset;
-                decryptedStream.WriteTo(inputStream);
+                byte[] buf = new byte[1000];
+                for (long pos = 0; pos < length; pos += buf.Length)
+                {
+                    int read = decryptedStream.Read(buf, 0, 1000);
+                    inputStream.Write(buf, 0, read);
+                }
             }
         }
     }
diff --git a/BinderTool.Core/Enc/EncFile.cs b/BinderTool.Core/Enc/EncFile.cs
index d55510a..6b2365c 100644
--- a/BinderTool.Core/Enc/EncFile.cs
+++ b/BinderTool.Core/Enc/EncFile.cs
@@ -19,7 +19,7 @@ private EncFile(byte[] key)
 
         private readonly byte[] _iv = new byte[EncryptionIvCbcSize];
 
-        public MemoryStream Data { get; private set; }
+        public Stream Data { get; private set; }
 
         public static EncFile ReadEncFile(Stream inputStream, byte[] key, GameVersion version = GameVersion.Common)
         {
diff --git a/BinderTool.Core/GameVersion.cs b/BinderTool.Core/GameVersion.cs
index 89c6ee2..40689e4 100644
--- a/BinderTool.Core/GameVersion.cs
+++ b/BinderTool.Core/GameVersion.cs
@@ -6,6 +6,7 @@ public enum GameVersion
         DarkSouls2,
         DarkSouls3,
         Bloodborne,
-        Sekiro
+        Sekiro,
+        EldenRing
     }
 }
\ No newline at end of file
diff --git a/BinderTool.Core/Sl2/Sl2UserData.cs b/BinderTool.Core/Sl2/Sl2UserData.cs
index b2921ec..167bf11 100644
--- a/BinderTool.Core/Sl2/Sl2UserData.cs
+++ b/BinderTool.Core/Sl2/Sl2UserData.cs
@@ -21,8 +21,10 @@ public Sl2UserData(byte[] key)
 
         public byte[] EncryptedUserData { get; private set; }
 
-        public byte[] DecryptedUserData => CryptographyUtility.DecryptAesCbc(new MemoryStream(EncryptedUserData), _key, _iv).ToArray();
-        
+        //public byte[] DecryptedUserData => CryptographyUtility.DecryptAesCbc(new MemoryStream(EncryptedUserData), _key, _iv).ToArray();
+        public byte[] DecryptedUserData => null;
+
+
         public static Sl2UserData ReadSl2UserData(Stream inputStream, byte[] key, int size, string name)
         {
             Sl2UserData sl2UserData = new Sl2UserData(key);
diff --git a/BinderTool/BinderTool.csproj b/BinderTool/BinderTool.csproj
index 0705577..f4066d8 100644
--- a/BinderTool/BinderTool.csproj
+++ b/BinderTool/BinderTool.csproj
@@ -99,6 +99,11 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="DictionaryER.csv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/BinderTool/DecryptionKeys.cs b/BinderTool/DecryptionKeys.cs
index 37be990..1c82c76 100644
--- a/BinderTool/DecryptionKeys.cs
+++ b/BinderTool/DecryptionKeys.cs
@@ -12,8 +12,12 @@ internal static class DecryptionKeys
 
         private static readonly Dictionary<string, string> SekiroRsaKeyDictionary;
 
+        private static readonly Dictionary<string, string> ErRsaKeyDictionary;
+
         private static readonly Dictionary<string, byte[]> Ds3AesKeyDictionary;
 
+        private static readonly Dictionary<string, byte[]> ErAesKeyDictionary;
+
         static DecryptionKeys()
         {
             Ds3RsaKeyDictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase)
@@ -37,11 +41,24 @@ static DecryptionKeys()
                 { "Data.bhd", SekiroArtworkKey }
             };
 
+            ErRsaKeyDictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase)
+            {
+                { "Data0.bhd", ErData0Key },
+                { "Data1.bhd", ErData1Key },
+                { "Data2.bhd", ErData2Key },
+                { "Data3.bhd", ErData3Key },
+            };
+
             Ds3AesKeyDictionary = new Dictionary<string, byte[]>(StringComparer.InvariantCultureIgnoreCase)
             {
                 { "regulation.regbnd.dcx.enc", RegulationFileKeyDs3 },
                 { "enc_regulation.bnd.dcx", RegulationFileKeyDs2 },
             };
+
+            ErAesKeyDictionary = new Dictionary<string, byte[]>(StringComparer.InvariantCultureIgnoreCase)
+            {
+                { "regulation.regbnd.dcx.enc", RegulationFileKeyEr },
+            };
         }
         
         public static bool TryGetRsaFileKey(GameVersion version, string file, out string key)
@@ -52,15 +69,26 @@ public static bool TryGetRsaFileKey(GameVersion version, string file, out string
                     return Ds3RsaKeyDictionary.TryGetValue(file, out key);
                 case GameVersion.Sekiro:
                     return SekiroRsaKeyDictionary.TryGetValue(file, out key);
+                case GameVersion.EldenRing:
+                    return ErRsaKeyDictionary.TryGetValue(file, out key);
             }
 
             key = null;
             return false;
         }
 
-        public static bool TryGetAesFileKey(string file, out byte[] key)
+        public static bool TryGetAesFileKey(GameVersion version, string file, out byte[] key)
         {
-            return Ds3AesKeyDictionary.TryGetValue(file, out key);
+            switch (version)
+            {
+                case GameVersion.DarkSouls3:
+                case GameVersion.DarkSouls2:
+                    return Ds3AesKeyDictionary.TryGetValue(file, out key);
+                case GameVersion.EldenRing:
+                    return ErAesKeyDictionary.TryGetValue(file, out key);
+            }
+            key = null;
+            return false;
         }
 
         /// <summary>
@@ -92,7 +120,13 @@ public static bool TryGetAesFileKey(string file, out byte[] key)
         /// <see cref="UserDataKeyDs3"/>
         /// </summary>
         public static readonly byte[] RegulationFileKeyDs3 = Encoding.ASCII.GetBytes("ds3#jn/8_7(rsY9pg55GFN7VFL#+3n/)");
-        
+
+        public static readonly byte[] RegulationFileKeyEr =
+        {
+            0x99, 0xBF, 0xFC, 0x36, 0x6A, 0x6B, 0xC8, 0xC6, 0xF5, 0x82, 0x7D, 0x09, 0x36, 0x02, 0xD6, 0x76,
+            0xC4, 0x28, 0x92, 0xA0, 0x1C, 0x20, 0x7F, 0xB0, 0x24, 0xD3, 0xAF, 0x4E, 0x49, 0x3F, 0xEF, 0x99
+        };
+
         public static readonly byte[] RegulationFileKeyDs2 =
         {
             0x40, 0x17, 0x81, 0x30, 0xDF, 0x0A, 0x94, 0x54,
@@ -258,6 +292,46 @@ public static bool TryGetAesFileKey(string file, out byte[] key)
 ks1k3uQ269NKZOpU6Q73I8yolUFGJFBlm9uHqRfZC0wcA+IXjo96C1PoTKJQktkh
 J07MPeoeckkAGdUv9S+kcDN04SAGMJJBWB9OOvn2Qle938gmCY6beeuk8c/l67zs
 ChgwGmsLdVr7W6hZL3aNvsf/BWFQ+e7+tQIFANZbM50=
+-----END RSA PUBLIC KEY-----";
+
+        private const string ErData0Key =
+@"-----BEGIN RSA PUBLIC KEY-----
+MIIBCwKCAQEA9Rju2whruXDVQZpfylVEPeNxm7XgMHcDyaaRUIpXQE0qEo+6Y36L
+P0xpFvL0H0kKxHwpuISsdgrnMHJ/yj4S61MWzhO8y4BQbw/zJehhDSRCecFJmFBz
+3I2JC5FCjoK+82xd9xM5XXdfsdBzRiSghuIHL4qk2WZ/0f/nK5VygeWXn/oLeYBL
+jX1S8wSSASza64JXjt0bP/i6mpV2SLZqKRxo7x2bIQrR1yHNekSF2jBhZIgcbtMB
+xjCywn+7p954wjcfjxB5VWaZ4hGbKhi1bhYPccht4XnGhcUTWO3NmJWslwccjQ4k
+sutLq3uRjLMM0IeTkQO6Pv8/R7UNFtdCWwIERzH8IQ==
+-----END RSA PUBLIC KEY-----";
+
+        private const string ErData1Key =
+@"-----BEGIN RSA PUBLIC KEY-----
+MIIBCwKCAQEAxaBCHQJrtLJiJNdG9nq3deA9sY4YCZ4dbTOHO+v+YgWRMcE6iK6o
+ZIJq+nBMUNBbGPmbRrEjkkH9M7LAypAFOPKC6wMHzqIMBsUMuYffulBuOqtEBD11
+CAwfx37rjwJ+/1tnEqtJjYkrK9yyrIN6Y+jy4ftymQtjk83+L89pvMMmkNeZaPON
+4O9q5M9PnFoKvK8eY45ZV/Jyk+Pe+xc6+e4h4cx8ML5U2kMM3VDAJush4z/05hS3
+/bC4B6K9+7dPwgqZgKx1J7DBtLdHSAgwRPpijPeOjKcAa2BDaNp9Cfon70oC+ZCB
++HkQ7FjJcF7KaHsH5oHvuI7EZAl2XTsLEQIENa/2JQ==
+-----END RSA PUBLIC KEY-----";
+
+        private const string ErData2Key =
+@"-----BEGIN RSA PUBLIC KEY-----
+MIIBDAKCAQEA0iDVVQ230RgrkIHJNDgxE7I/2AaH6Li1Eu9mtpfrrfhfoK2e7y4O
+WU+lj7AGI4GIgkWpPw8JHaV970Cr6+sTG4Tr5eMQPxrCIH7BJAPCloypxcs2BNfT
+GXzm6veUfrGzLIDp7wy24lIA8r9ZwUvpKlN28kxBDGeCbGCkYeSVNuF+R9rN4OAM
+RYh0r1Q950xc2qSNloNsjpDoSKoYN0T7u5rnMn/4mtclnWPVRWU940zr1rymv4Jc
+3umNf6cT1XqrS1gSaK1JWZfsSeD6Dwk3uvquvfY6YlGRygIlVEMAvKrDRMHylsLt
+qqhYkZNXMdy0NXopf1rEHKy9poaHEmJldwIFAP////8=
+-----END RSA PUBLIC KEY-----";
+
+        private const string ErData3Key =
+@"-----BEGIN RSA PUBLIC KEY-----
+MIIBCwKCAQEAvRRNBnVq3WknCNHrJRelcEA2v/OzKlQkxZw1yKll0Y2Kn6G9ts94
+SfgZYbdFCnIXy5NEuyHRKrxXz5vurjhrcuoYAI2ZUhXPXZJdgHywac/i3S/IY0V/
+eDbqepyJWHpP6I565ySqlol1p/BScVjbEsVyvZGtWIXLPDbx4EYFKA5B52uK6Gdz
+4qcyVFtVEhNoMvg+EoWnyLD7EUzuB2Khl46CuNictyWrLlIHgpKJr1QD8a0ld0PD
+PHDZn03q6QDvZd23UW2d9J+/HeBt52j08+qoBXPwhndZsmPMWngQDaik6FM7EVRQ
+etKPi6h5uprVmMAS5wR/jQIVTMpTj/zJdwIEXszeQw==
 -----END RSA PUBLIC KEY-----";
     }
 }
diff --git a/BinderTool/DictionaryER.csv b/BinderTool/DictionaryER.csv
new file mode 100644
index 0000000..5f28270
--- /dev/null
+++ b/BinderTool/DictionaryER.csv
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/BinderTool/FileNameDictionary.cs b/BinderTool/FileNameDictionary.cs
index 5bba823..81a5b2b 100644
--- a/BinderTool/FileNameDictionary.cs
+++ b/BinderTool/FileNameDictionary.cs
@@ -302,6 +302,7 @@ public static FileNameDictionary OpenFromFile(GameVersion version)
         public static FileNameDictionary OpenFromFile(string dictionaryPath, GameVersion version)
         {
             var dictionary = new FileNameDictionary(version);
+            if (!File.Exists(dictionaryPath)) return dictionary;
 
             string[] lines = File.ReadAllLines(dictionaryPath);
             foreach (string line in lines)
diff --git a/BinderTool/Options.cs b/BinderTool/Options.cs
index daa4040..adfb078 100644
--- a/BinderTool/Options.cs
+++ b/BinderTool/Options.cs
@@ -9,11 +9,11 @@ internal class Options
     {
         public GameVersion InputGameVersion { get; set; }
 
-        public FileType InputType { get; private set; }
+        public FileType InputType { get; set; }
 
-        public string InputPath { get; private set; }
+        public string InputPath { get; set; }
 
-        public string OutputPath { get; private set; }
+        public string OutputPath { get; set; }
 
         internal static Options Parse(string[] args)
         {
diff --git a/BinderTool/Program.cs b/BinderTool/Program.cs
index f6fef81..123746d 100644
--- a/BinderTool/Program.cs
+++ b/BinderTool/Program.cs
@@ -22,13 +22,14 @@ public static class Program
     {
         private static void Main(string[] args)
         {
+            
+            Options options;
             if (args.Length == 0)
             {
                 ShowUsageInfo();
                 return;
             }
 
-            Options options;
             try
             {
                 options = Options.Parse(args);
@@ -123,7 +124,7 @@ private static void UnpackBdtFile(Options options)
                 {
                     foreach (var entry in bucket.GetEntries())
                     {
-                        MemoryStream data;
+                        Stream data;
                         if (entry.FileSize == 0)
                         {
                             long fileSize;
@@ -141,7 +142,7 @@ private static void UnpackBdtFile(Options options)
                             data = bdtStream.Read(entry.FileOffset, entry.PaddedFileSize);
                             CryptographyUtility.DecryptAesEcb(data, entry.AesKey.Key, entry.AesKey.Ranges);
                             data.Position = 0;
-                            data.SetLength(entry.FileSize);
+                            //data.SetLength(entry.FileSize);
                         }
                         else
                         {
@@ -176,7 +177,7 @@ private static void UnpackBdtFile(Options options)
                         if (extension == ".enc")
                         {
                             byte[] decryptionKey;
-                            if (DecryptionKeys.TryGetAesFileKey(Path.GetFileName(fileName), out decryptionKey))
+                            if (DecryptionKeys.TryGetAesFileKey(options.InputGameVersion, Path.GetFileName(fileName), out decryptionKey))
                             {
                                 EncFile encFile = EncFile.ReadEncFile(data, decryptionKey);
                                 data = encFile.Data;
@@ -220,9 +221,22 @@ private static void UnpackBdtFile(Options options)
                             entry.IsEncrypted,
                             fileNameFound);
 
+                        if (extension == ".bnd")
+                        {
+                            UnpackBndFile(data, options.OutputPath + "\\bnd");
+                            continue;
+                        }
                         string newFileNamePath = Path.Combine(options.OutputPath, fileName);
                         Directory.CreateDirectory(Path.GetDirectoryName(newFileNamePath));
-                        File.WriteAllBytes(newFileNamePath, data.ToArray());
+                        FileStream outS = new FileStream(newFileNamePath, FileMode.OpenOrCreate);
+                        byte[] buf = new byte[1000];
+                        data.Seek(0, SeekOrigin.Begin);
+                        for (long pos = 0; pos < data.Length; pos += buf.Length)
+                        {
+                            int read = data.Read(buf, 0, buf.Length);
+                            outS.Write(buf, 0, read);
+                        }
+                        outS.Close();
                     }
                 }
             }
@@ -233,7 +247,7 @@ private static bool TryReadFileSize(Bhd5BucketEntry entry, Bdt5FileStream bdtStr
             fileSize = 0;
 
             const int sampleLength = 48;
-            MemoryStream data = bdtStream.Read(entry.FileOffset, sampleLength);
+            Stream data = bdtStream.Read(entry.FileOffset, sampleLength);
 
             if (entry.IsEncrypted)
             {
@@ -251,7 +265,7 @@ private static bool TryReadFileSize(Bhd5BucketEntry entry, Bdt5FileStream bdtStr
             return true;
         }
 
-        private static string GetDataExtension(MemoryStream data)
+        private static string GetDataExtension(Stream data)
         {
             string signature;
             string extension;
@@ -279,19 +293,19 @@ private static string GetDataExtension(MemoryStream data)
             return ".bin";
         }
 
-        private static bool TryGetAsciiSignature(MemoryStream stream, int signatureLength, out string signature)
+        private static bool TryGetAsciiSignature(Stream stream, int signatureLength, out string signature)
         {
             const int asciiBytesPerChar = 1;
             return TryGetSignature(stream, Encoding.ASCII, asciiBytesPerChar, signatureLength, out signature);
         }
 
-        private static bool TryGetUnicodeSignature(MemoryStream stream, int signatureLength, out string signature)
+        private static bool TryGetUnicodeSignature(Stream stream, int signatureLength, out string signature)
         {
             const int unicodeBytesPerChar = 2;
             return TryGetSignature(stream, Encoding.Unicode, unicodeBytesPerChar, signatureLength, out signature);
         }
 
-        private static bool TryGetSignature(MemoryStream stream, Encoding encoding, int bytesPerChar, int signatureLength, out string signature)
+        private static bool TryGetSignature(Stream stream, Encoding encoding, int bytesPerChar, int signatureLength, out string signature)
         {
             signature = null;
 
@@ -319,7 +333,7 @@ private static bool TryGetFileExtension(string signature, out string extension)
                     extension = ".bhd";
                     return true;
                 case "BDF4":
-                    extension = ".bdt";
+                    extension = ".bdf";
                     return true;
                 case "DCX\0":
                     extension = ".dcx";
@@ -439,11 +453,15 @@ private static void UnpackBndFile(Stream inputStream, string outputPath)
 
             foreach (var entry in file.Entries)
             {
-                string fileName = FileNameDictionary.NormalizeFileName(entry.FileName);
-                string outputFilePath = Path.Combine(outputPath, fileName);
-
-                Directory.CreateDirectory(Path.GetDirectoryName(outputFilePath));
-                File.WriteAllBytes(outputFilePath, entry.EntryData);
+                try
+                {
+                    string fileName = FileNameDictionary.NormalizeFileName(entry.FileName);
+                    string outputFilePath = Path.Combine(outputPath, fileName);
+                    //continue;
+                    Directory.CreateDirectory(Path.GetDirectoryName(outputFilePath));
+                    File.WriteAllBytes(outputFilePath, entry.EntryData);
+                }
+                catch (Exception e) { }
             }
         }
 
@@ -502,6 +520,9 @@ private static byte[] GetRegulationKey(GameVersion version)
                 case GameVersion.DarkSouls3:
                     key = DecryptionKeys.RegulationFileKeyDs3;
                     break;
+                case GameVersion.EldenRing:
+                    key = DecryptionKeys.RegulationFileKeyEr;
+                    break;
                 default:
                     key = new byte[16];
                     break;
@@ -614,6 +635,7 @@ private static MemoryStream DecryptBhdFile(string filePath, GameVersion version)
                     break;
                 case GameVersion.DarkSouls3:
                 case GameVersion.Sekiro:
+                case GameVersion.EldenRing:
                     DecryptionKeys.TryGetRsaFileKey(version, fileName, out key);
                     break;
             }