Fix framework string

.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/Test/bin/Debug/netcoreapp3.1/Test.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/Test",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,42 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Test/Test.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/Test/Test.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "${workspaceFolder}/Test/Test.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

BurnOutSharp/BurnOutSharp.csproj

@@ -1,19 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net472;net48;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net472;net48;netcoreapp3.1;net5.0</TargetFrameworks>
     <PlatformTarget>x86</PlatformTarget>
     <Title>BurnOutSharp</Title>
     <AssemblyName>BurnOutSharp</AssemblyName>
     <Description>Port of BurnOut to C#, with additions</Description>
     <Authors>Matt Nadareski;Gernot Knippen</Authors>
     <Product>BurnOutSharp</Product>
-    <Copyright>Copyright (c)2005-2010 Gernot Knippen, Copyright (c)2018-2020 Matt Nadareski</Copyright>
+    <Copyright>Copyright (c)2005-2010 Gernot Knippen, Copyright (c)2018-2021 Matt Nadareski</Copyright>
     <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
     <RepositoryUrl>https://github.com/mnadareski/BurnOutSharp</RepositoryUrl>
-    <Version>1.5.0</Version>
-    <AssemblyVersion>1.5.0</AssemblyVersion>
-    <FileVersion>1.5.0</FileVersion>
+    <Version>1.5.1</Version>
+    <AssemblyVersion>1.5.1</AssemblyVersion>
+    <FileVersion>1.5.1</FileVersion>
     <IncludeSource>true</IncludeSource>
     <IncludeSymbols>true</IncludeSymbols>
   </PropertyGroup>
@@ -22,17 +22,17 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   
-  <PropertyGroup Condition="'$(TargetFramework)'!='netcoreapp3.1'">
+  <PropertyGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <DefineConstants>NET_FRAMEWORK</DefineConstants>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="LessIO" Version="1.0.34" Condition="'$(TargetFramework)'!='netcoreapp3.1'" />
-    <PackageReference Include="libmspack4n" Version="0.9.10" Condition="'$(TargetFramework)'!='netcoreapp3.1'" />
+    <PackageReference Include="LessIO" Version="1.0.34" Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'" />
+    <PackageReference Include="libmspack4n" Version="0.9.10" Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'" />
     <PackageReference Include="SharpCompress" Version="0.26.0" />
     <PackageReference Include="UnshieldSharp" Version="1.4.2.4" />
     <PackageReference Include="WiseUnpacker" Version="1.0.1" />
-    <PackageReference Include="wix-libs" Version="3.11.1" Condition="'$(TargetFramework)'!='netcoreapp3.1'" />
+    <PackageReference Include="wix-libs" Version="3.11.1" Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'" />
   </ItemGroup>
 
   <ItemGroup>

BurnOutSharp/EVORE.cs

@@ -19,45 +19,37 @@
 using System;
 using System.Diagnostics;
 using System.IO;
-using System.Text;
-using System.Threading;
+using System.Runtime.InteropServices;
+using BurnOutSharp.ExecutableType.Microsoft;
 
 namespace BurnOutSharp
 {
     internal static class EVORE
     {
-        private struct Section
+        /// <summary>
+        /// Checks if the file contents that represent a PE is a DLL or an EXE
+        /// </summary>
+        /// <param name="fileContent">File contents to check</param>
+        /// <returns>True if the file is an EXE, false if it's a DLL</returns>
+        internal static bool IsEXE(byte[] fileContent)
         {
-            public uint iVirtualSize;
-            public uint iVirtualOffset;
-            public uint iRawOffset;
+            int PEHeaderOffset = BitConverter.ToInt32(fileContent, 60);
+            short Characteristics = BitConverter.ToInt16(fileContent, PEHeaderOffset + 22);
+
+            // Check if file is dll
+            if ((Characteristics & 0x2000) == 0x2000)
+                return false;
+            else
+                return true;
         }
 
-        private const int WaitSeconds = 20;
-
-        private static Process StartSafe(string file)
-        {
-            if (file == null || !File.Exists(file))
-                return null;
-
-            Process startingprocess = new Process();
-            startingprocess.StartInfo.FileName = file;
-            startingprocess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
-            startingprocess.StartInfo.CreateNoWindow = true;
-            startingprocess.StartInfo.ErrorDialog = false;
-            try
-            {
-                startingprocess.Start();
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine(ex.Message);
-                return null;
-            }
-            return startingprocess;
-        }
-
-        private static string MakeTempFile(byte[] fileContent, string sExtension = ".exe")
+        /// <summary>
+        /// Writes the file contents to a temporary file, if possible
+        /// </summary>
+        /// <param name="fileContent">File contents to write</param>
+        /// <param name="sExtension">Optional extension for the temproary file, defaults to ".exe"</param>
+        /// <returns>Name of the new temporary file, null on error</returns>
+        internal static string MakeTempFile(byte[] fileContent, string sExtension = ".exe")
         {
             string filei = Guid.NewGuid().ToString();
             string tempPath = Path.Combine(Path.GetTempPath(), "tmp", $"{filei}{sExtension}");
@@ -82,21 +74,15 @@ namespace BurnOutSharp
             return null;
         }
 
-        private static bool IsEXE(byte[] fileContent)
+        /// <summary>
+        /// Copies all required DLLs for a given executable
+        /// </summary>
+        /// <param name="file">Temporary file path</param>
+        /// <param name="fileContent">File contents to read</param>
+        /// <returns>Paths for all of the copied DLLs, null on error</returns>
+        internal static string[] CopyDependentDlls(string file, byte[] fileContent)
         {
-            int PEHeaderOffset = BitConverter.ToInt32(fileContent, 60);
-            short Characteristics = BitConverter.ToInt16(fileContent, PEHeaderOffset + 22);
-
-            // Check if file is dll
-            if ((Characteristics & 0x2000) == 0x2000)
-                return false;
-            else
-                return true;
-        }
-
-        private static string[] CopyDependentDlls(string file, byte[] fileContent)
-        {
-            Section[] sections = ReadSections(fileContent);
+            var sections = ReadSections(fileContent);
 
             long lastPosition;
             string[] saDependentDLLs = null;
@@ -152,295 +138,104 @@ namespace BurnOutSharp
             return saDependentDLLs;
         }
 
-        private static Section[] ReadSections(byte[] fileContent)
+        /// <summary>
+        /// Attempt to run an executable
+        /// </summary>
+        /// <param name="file">Executable to attempt to run</param>
+        /// <returns>Process representing the running executable, null on error</returns>
+        internal static Process StartSafe(string file)
+        {
+            if (file == null || !File.Exists(file))
+                return null;
+
+            Process startingprocess = new Process();
+            startingprocess.StartInfo.FileName = file;
+            startingprocess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+            startingprocess.StartInfo.CreateNoWindow = true;
+            startingprocess.StartInfo.ErrorDialog = false;
+            try
+            {
+                startingprocess.Start();
+            }
+            catch
+            {
+                return null;
+            }
+
+            return startingprocess;
+        }
+
+        private static IMAGE_SECTION_HEADER?[] ReadSections(byte[] fileContent)
         {
             if (fileContent == null)
                 return null;
 
             uint PEHeaderOffset = BitConverter.ToUInt32(fileContent, 60);
             ushort NumberOfSections = BitConverter.ToUInt16(fileContent, (int)PEHeaderOffset + 6);
-            Section[] sections = new Section[NumberOfSections];
+            var sections = new IMAGE_SECTION_HEADER?[NumberOfSections];
             int index = (int)PEHeaderOffset + 120 + 16 * 8;            
             for (int i = 0; i < NumberOfSections; i++)
             {
-                index += 8;
-                uint ivs = BitConverter.ToUInt32(fileContent, index);
-                index += 4;
-                uint ivo = BitConverter.ToUInt32(fileContent, index);
-                index += 4;
-                index += 4;
-                uint iro = BitConverter.ToUInt32(fileContent, index);
-                index += 4;
-                index += 16;
-
-                sections[i] = new Section()
-                {
-                    iVirtualSize = ivs,
-                    iVirtualOffset = ivo,
-                    iRawOffset = iro,
-                };
+                sections[i] = ReadSection(fileContent, index);
             }
 
             return sections;
         }
 
-        private static uint RVA2Offset(uint RVA, Section[] sections)
+        private static IMAGE_SECTION_HEADER? ReadSection(byte[] fileContent, int ptr)
         {
-            int i = 0;
-            while (i != sections.Length)
+            // Get the size of a section header for later
+            int sectionSize = Marshal.SizeOf<IMAGE_SECTION_HEADER>();
+
+            // If the contents are null or the wrong size, we can't read a section
+            if (fileContent == null || fileContent.Length < sectionSize)
+                return null;
+
+            // Create a new section and try our best to read one
+            IMAGE_SECTION_HEADER? section = null;
+            IntPtr tempPtr = IntPtr.Zero;
+            try
             {
-                if (sections[i].iVirtualOffset <= RVA && sections[i].iVirtualOffset + sections[i].iVirtualSize > RVA)
-                    return RVA - sections[i].iVirtualOffset + sections[i].iRawOffset;
-                i++;
+                // Get the pointer to where the section will go
+                tempPtr = Marshal.AllocHGlobal(sectionSize);
+                
+                // If we couldn't get the space, just return null
+                if (tempPtr == IntPtr.Zero)
+                    return null;
+
+                // Copy from the array to the new space
+                Marshal.Copy(fileContent, ptr, tempPtr, sectionSize);
+
+                // Get the new section and return
+                section = Marshal.PtrToStructure<IMAGE_SECTION_HEADER>(tempPtr);
             }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+            finally
+            {
+                if (tempPtr != IntPtr.Zero)
+                    Marshal.FreeHGlobal(tempPtr);
+            }
+
+            return section;
+        }
+
+        private static uint RVA2Offset(uint RVA, IMAGE_SECTION_HEADER?[] sections)
+        {
+            for (int i = 0; i < sections.Length; i++)
+            {
+                if (!sections[i].HasValue)
+                    continue;
+
+                var section = sections[i].Value;
+                if (section.VirtualAddress <= RVA && section.VirtualAddress + section.PhysicalAddressOrVirtualSize > RVA)
+                    return RVA - section.VirtualAddress + section.PointerToRawData;
+            }
+
             return 0;
         }
-
-        #region "EVORE version-search-functions"
-
-        public static string SearchProtectDiscVersion(string file, byte[] fileContent)
-        {
-            string version = "";
-            DateTime timestart;
-            if (!IsEXE(fileContent))
-                return "";
-
-            string tempexe = MakeTempFile(fileContent);
-            string[] DependentDlls = CopyDependentDlls(file, fileContent);
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
-            }
-            catch { }
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
-            }
-            catch { }
-            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
-            {
-                try
-                {
-                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
-                }
-                catch { }
-            }
-
-            Process exe = StartSafe(tempexe);
-            if (exe == null)
-                return "";
-
-            Process[] processes = new Process[0];
-            timestart = DateTime.Now;
-            do
-            {
-                exe.Refresh();
-                string[] files = null;
-
-                //check for ProtectDisc 8.2-x
-                if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
-                {
-                    files = Directory.GetFiles(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc"), "p*.dll");
-                }
-
-                if (files != null)
-                {
-                    if (files.Length > 0)
-                    {
-                        FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
-                        if (fvinfo.FileVersion != "")
-                        {
-                            version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
-                            //ProtectDisc 9 uses a ProtectDisc-Core dll version 8.0.x
-                            if (version.StartsWith("8.0"))
-                                version = "";
-                            fvinfo = null;
-                            break;
-                        }
-                    }
-                }
-
-                //check for ProtectDisc 7.1-8.1
-                files = Directory.GetFiles(Path.GetTempPath(), "a*.tmp");
-                if (files.Length > 0)
-                {
-                    FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
-                    if (fvinfo.FileVersion != "")
-                    {
-                        version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
-                        fvinfo = null;
-                        break;
-                    }
-                }
-
-                if (exe.HasExited)
-                    break;
-
-                processes = Process.GetProcessesByName(exe.ProcessName);
-                if (processes.Length == 2)
-                {
-                    processes[0].Refresh();
-                    processes[1].Refresh();
-                    if (processes[1].WorkingSet64 > exe.WorkingSet64)
-                        exe = processes[1];
-                    else if (processes[0].WorkingSet64 > exe.WorkingSet64) //else if (processes[0].Modules.Count > exe.Modules.Count)
-                        exe = processes[0];
-                }
-            } while (processes.Length > 0 && DateTime.Now.Subtract(timestart).TotalSeconds < WaitSeconds);
-
-            Thread.Sleep(500);
-            if (!exe.HasExited)
-            {
-                processes = Process.GetProcessesByName(exe.ProcessName);
-                if (processes.Length == 2)
-                {
-                    try
-                    {
-                        processes[0].Kill();
-                    }
-                    catch { }
-                    processes[0].Close();
-                    try
-                    {
-                        processes[1].Kill();
-                    }
-                    catch { }
-                }
-                else
-                {
-                    exe.Refresh();
-                    try
-                    {
-                        exe.Kill();
-                    }
-                    catch { }
-                }
-            }
-
-            exe.Close();
-            Thread.Sleep(500);
-            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
-            {
-                try
-                {
-                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
-                }
-                catch { }
-            }
-
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
-            }
-            catch { }
-
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
-            }
-            catch { }
-            File.Delete(tempexe);
-            if (DependentDlls != null)
-            {
-                for (int i = 0; i < DependentDlls.Length; i++)
-                {
-                    try
-                    {
-                        File.Delete(DependentDlls[i]);
-                    }
-                    catch (Exception ex)
-                    {
-                        Console.WriteLine("!error while deleting file " + DependentDlls[i] + "; " + ex.Message);
-                    }
-                }
-            }
-
-            return version;
-        }
-
-        public static string SearchSafeDiscVersion(string file, byte[] fileContent)
-        {
-            Process exe = new Process();
-            string version = "";
-            DateTime timestart;
-            if (!IsEXE(fileContent))
-                return "";
-
-            string tempexe = MakeTempFile(fileContent);
-            string[] DependentDlls = CopyDependentDlls(file, fileContent);
-            try
-            {
-                Directory.Delete(Path.Combine(Path.GetTempPath(), "~e*"), true);
-            }
-            catch { }
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "~e*"));
-            }
-            catch { }
-
-            exe = StartSafe(tempexe);
-            if (exe == null)
-                return "";
-
-            timestart = DateTime.Now;
-            do
-            {
-                if (Directory.GetDirectories(Path.GetTempPath(), "~e*").Length > 0)
-                {
-                    string[] files = Directory.GetFiles(Directory.GetDirectories(Path.GetTempPath(), "~e*")[0], "~de*.tmp");
-                    if (files.Length > 0)
-                    {
-                        StreamReader sr;
-                        try
-                        {
-                            sr = new StreamReader(files[0], Encoding.Default);
-                            string FileContent = sr.ReadToEnd();
-                            sr.Close();
-                            int position = FileContent.IndexOf("%ld.%ld.%ld, %ld, %s,") - 1;
-                            if (position > -1)
-                                version = FileContent.Substring(position + 28, 12);
-                            break;
-                        }
-                        catch { }
-                    }
-                }
-            } while (!exe.HasExited && DateTime.Now.Subtract(timestart).TotalSeconds < WaitSeconds);
-
-            if (!exe.HasExited)
-                exe.Kill();
-            exe.Close();
-
-            try
-            {
-                Directory.Delete(Path.Combine(Path.GetTempPath(), "~e*"), true);
-            }
-            catch { }
-            try
-            {
-                File.Delete(Path.Combine(Path.GetTempPath(), "~e*"));
-                File.Delete(tempexe);
-            }
-            catch { }
-
-            if (DependentDlls != null)
-            {
-                for (int i = 0; i < DependentDlls.Length; i--)
-                {
-                    try
-                    {
-                        File.Delete(DependentDlls[i]);
-                    }
-                    catch (Exception ex)
-                    {
-                        Console.WriteLine("!error while deleting file " + DependentDlls[i] + "; " + ex.Message);
-                    }
-                }
-            }
-
-            return version;
-        }
-
-        #endregion
     }
 }

BurnOutSharp/ExecutableType/Microsoft/IMAGE_DATA_DIRECTORY.cs

@@ -0,0 +1,12 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_DATA_DIRECTORY
+    {
+        public uint VirtualAddress;
+        public uint Size;
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_DOS_HEADER.cs

@@ -0,0 +1,30 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_DOS_HEADER
+    {
+        public ushort e_magic;      /* 00: MZ Header signature */
+        public ushort e_cblp;       /* 02: Bytes on last page of file */
+        public ushort e_cp;         /* 04: Pages in file */
+        public ushort e_crlc;       /* 06: Relocations */
+        public ushort e_cparhdr;    /* 08: Size of header in paragraphs */
+        public ushort e_minalloc;   /* 0a: Minimum extra paragraphs needed */
+        public ushort e_maxalloc;   /* 0c: Maximum extra paragraphs needed */
+        public ushort e_ss;         /* 0e: Initial (relative) SS value */
+        public ushort e_sp;         /* 10: Initial SP value */
+        public ushort e_csum;       /* 12: Checksum */
+        public ushort e_ip;         /* 14: Initial IP value */
+        public ushort e_cs;         /* 16: Initial (relative) CS value */
+        public ushort e_lfarlc;     /* 18: File address of relocation table */
+        public ushort e_ovno;       /* 1a: Overlay number */
+        public ushort[] e_res;      /* 1c: Reserved words [4] */
+        public ushort e_oemid;      /* 24: OEM identifier (for e_oeminfo) */
+        public ushort e_oeminfo;    /* 26: OEM information; e_oemid specific */
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
+        public ushort[] e_res2;     /* 28: Reserved words [10] */
+        public uint e_lfanew;       /* 3c: Offset to extended header */
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_FILE_HEADER.cs

@@ -0,0 +1,17 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_FILE_HEADER
+    {
+        public ushort Machine;
+        public ushort NumberOfSections;
+        public uint TimeDateStamp;
+        public uint PointerToSymbolTable;
+        public uint NumberOfSymbols;
+        public ushort SizeOfOptionalHeader;
+        public FileCharacteristics Characteristics;
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_NT_HEADERS32.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_NT_HEADERS32
+    {
+        public uint Signature; /* "PE"\0\0 */   /* 0x00 */
+        public IMAGE_FILE_HEADER FileHeader;       /* 0x04 */
+        public IMAGE_OPTIONAL_HEADER32 OptionalHeader;	/* 0x18 */
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_NT_HEADERS64.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_NT_HEADERS64
+    {
+        public uint Signature;
+        public IMAGE_FILE_HEADER FileHeader;
+        public IMAGE_OPTIONAL_HEADER64 OptionalHeader;
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_OPTIONAL_HEADER32.cs

@@ -0,0 +1,48 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_OPTIONAL_HEADER32
+    {
+        /* Standard fields */
+
+        public ushort Magic; /* 0x10b or 0x107 */    /* 0x00 */
+        public byte MajorLinkerVersion;
+        public byte MinorLinkerVersion;
+        public uint SizeOfCode;
+        public uint SizeOfInitializedData;
+        public uint SizeOfUninitializedData;
+        public uint AddressOfEntryPoint;      /* 0x10 */
+        public uint BaseOfCode;
+        public uint BaseOfData;
+
+        /* NT additional fields */
+
+        public uint ImageBase;
+        public uint SectionAlignment;     /* 0x20 */
+        public uint FileAlignment;
+        public ushort MajorOperatingSystemVersion;
+        public ushort MinorOperatingSystemVersion;
+        public ushort MajorImageVersion;
+        public ushort MinorImageVersion;
+        public ushort MajorSubsystemVersion;     /* 0x30 */
+        public ushort MinorSubsystemVersion;
+        public uint Win32VersionValue;
+        public uint SizeOfImage;
+        public uint SizeOfHeaders;
+        public uint CheckSum;         /* 0x40 */
+        public ushort Subsystem;
+        public DllCharacteristics DllCharacteristics;
+        public uint SizeOfStackReserve;
+        public uint SizeOfStackCommit;
+        public uint SizeOfHeapReserve;        /* 0x50 */
+        public uint SizeOfHeapCommit;
+        public uint LoaderFlags;
+        public uint NumberOfRvaAndSizes;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.IMAGE_NUMBEROF_DIRECTORY_ENTRIES)]
+        public IMAGE_DATA_DIRECTORY[] DataDirectory; /* 0x60, [IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
+        /* 0xE0 */
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_OPTIONAL_HEADER64.cs

@@ -0,0 +1,41 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_OPTIONAL_HEADER64
+    {
+        public ushort Magic; /* 0x20b */
+        public byte MajorLinkerVersion;
+        public byte MinorLinkerVersion;
+        public uint SizeOfCode;
+        public uint SizeOfInitializedData;
+        public uint SizeOfUninitializedData;
+        public uint AddressOfEntryPoint;
+        public uint BaseOfCode;
+        public ulong ImageBase;
+        public uint SectionAlignment;
+        public uint FileAlignment;
+        public ushort MajorOperatingSystemVersion;
+        public ushort MinorOperatingSystemVersion;
+        public ushort MajorImageVersion;
+        public ushort MinorImageVersion;
+        public ushort MajorSubsystemVersion;
+        public ushort MinorSubsystemVersion;
+        public uint Win32VersionValue;
+        public uint SizeOfImage;
+        public uint SizeOfHeaders;
+        public uint CheckSum;
+        public ushort Subsystem;
+        public DllCharacteristics DllCharacteristics;
+        public ulong SizeOfStackReserve;
+        public ulong SizeOfStackCommit;
+        public ulong SizeOfHeapReserve;
+        public ulong SizeOfHeapCommit;
+        public uint LoaderFlags;
+        public uint NumberOfRvaAndSizes;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.IMAGE_NUMBEROF_DIRECTORY_ENTRIES)]
+        public IMAGE_DATA_DIRECTORY[] DataDirectory; // [IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_OS2_HEADER.cs

@@ -0,0 +1,40 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_OS2_HEADER
+    {
+        public ushort ne_magic;           /* 00 NE signature 'NE' */
+        public byte ne_ver;               /* 02 Linker version number */
+        public byte ne_rev;               /* 03 Linker revision number */
+        public ushort ne_enttab;          /* 04 Offset to entry table relative to NE */
+        public ushort ne_cbenttab;        /* 06 Length of entry table in bytes */
+        public uint ne_crc;               /* 08 Checksum */
+        public ushort ne_flags;           /* 0c Flags about segments in this file */
+        public ushort ne_autodata;        /* 0e Automatic data segment number */
+        public ushort ne_heap;            /* 10 Initial size of local heap */
+        public ushort ne_stack;           /* 12 Initial size of stack */
+        public uint ne_csip;              /* 14 Initial CS:IP */
+        public uint ne_sssp;              /* 18 Initial SS:SP */
+        public ushort ne_cseg;            /* 1c # of entries in segment table */
+        public ushort ne_cmod;            /* 1e # of entries in module reference tab. */
+        public ushort ne_cbnrestab;       /* 20 Length of nonresident-name table     */
+        public ushort ne_segtab;          /* 22 Offset to segment table */
+        public ushort ne_rsrctab;         /* 24 Offset to resource table */
+        public ushort ne_restab;          /* 26 Offset to resident-name table */
+        public ushort ne_modtab;          /* 28 Offset to module reference table */
+        public ushort ne_imptab;          /* 2a Offset to imported name table */
+        public uint ne_nrestab;           /* 2c Offset to nonresident-name table */
+        public ushort ne_cmovent;         /* 30 # of movable entry points */
+        public ushort ne_align;           /* 32 Logical sector alignment shift count */
+        public ushort ne_cres;            /* 34 # of resource segments */
+        public byte ne_exetyp;            /* 36 Flags indicating target OS */
+        public byte ne_flagsothers;       /* 37 Additional information flags */
+        public ushort ne_pretthunks;      /* 38 Offset to return thunks */
+        public ushort ne_psegrefbytes;    /* 3a Offset to segment ref. bytes */
+        public ushort ne_swaparea;        /* 3c Reserved by Microsoft */
+        public ushort ne_expver;          /* 3e Expected Windows version number */
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_SECTION_HEADER.cs

@@ -0,0 +1,21 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_SECTION_HEADER
+    {
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.IMAGE_SIZEOF_SHORT_NAME)]
+        public byte[] Name; // [IMAGE_SIZEOF_SHORT_NAME];
+        public uint PhysicalAddressOrVirtualSize; // Misc
+        public uint VirtualAddress;
+        public uint SizeOfRawData;
+        public uint PointerToRawData;
+        public uint PointerToRelocations;
+        public uint PointerToLinenumbers;
+        public ushort NumberOfRelocations;
+        public ushort NumberOfLinenumbers;
+        public SectionCharacteristics Characteristics;
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/IMAGE_VXD_HEADER.cs

@@ -0,0 +1,62 @@
+using System.Runtime.InteropServices;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct IMAGE_VXD_HEADER
+    {
+        public ushort e32_magic;
+        public byte e32_border;
+        public byte e32_worder;
+        public uint e32_level;
+        public ushort e32_cpu;
+        public ushort e32_os;
+        public uint e32_ver;
+        public uint e32_mflags;
+        public uint e32_mpages;
+        public uint e32_startobj;
+        public uint e32_eip;
+        public uint e32_stackobj;
+        public uint e32_esp;
+        public uint e32_pagesize;
+        public uint e32_lastpagesize;
+        public uint e32_fixupsize;
+        public uint e32_fixupsum;
+        public uint e32_ldrsize;
+        public uint e32_ldrsum;
+        public uint e32_objtab;
+        public uint e32_objcnt;
+        public uint e32_objmap;
+        public uint e32_itermap;
+        public uint e32_rsrctab;
+        public uint e32_rsrccnt;
+        public uint e32_restab;
+        public uint e32_enttab;
+        public uint e32_dirtab;
+        public uint e32_dircnt;
+        public uint e32_fpagetab;
+        public uint e32_frectab;
+        public uint e32_impmod;
+        public uint e32_impmodcnt;
+        public uint e32_impproc;
+        public uint e32_pagesum;
+        public uint e32_datapage;
+        public uint e32_preload;
+        public uint e32_nrestab;
+        public uint e32_cbnrestab;
+        public uint e32_nressum;
+        public uint e32_autodata;
+        public uint e32_debuginfo;
+        public uint e32_debuglen;
+        public uint e32_instpreload;
+        public uint e32_instdemand;
+        public uint e32_heapsize;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
+        public byte[] e32_res3; // [12]
+        public uint e32_winresoff;
+        public uint e32_winreslen;
+        public ushort e32_devid;
+        public ushort e32_ddkver;
+    }
+}

BurnOutSharp/ExecutableType/Microsoft/winnt.cs

@@ -0,0 +1,203 @@
+using System;
+
+// Converted from https://github.com/wine-mirror/wine/blob/master/include/winnt.h
+namespace BurnOutSharp.ExecutableType.Microsoft
+{
+    internal enum DirectoryEntries
+    {
+        IMAGE_DIRECTORY_ENTRY_EXPORT = 0,
+        IMAGE_DIRECTORY_ENTRY_IMPORT = 1,
+        IMAGE_DIRECTORY_ENTRY_RESOURCE = 2,
+        IMAGE_DIRECTORY_ENTRY_EXCEPTION = 3,
+        IMAGE_DIRECTORY_ENTRY_SECURIT = 4,
+        IMAGE_DIRECTORY_ENTRY_BASERELOC = 5,
+        IMAGE_DIRECTORY_ENTRY_DEBUG = 6,
+        IMAGE_DIRECTORY_ENTRY_COPYRIGHT = 7,
+        IMAGE_DIRECTORY_ENTRY_GLOBALPTR = 8, // (MIPS GP)
+        IMAGE_DIRECTORY_ENTRY_TLS = 9,
+        IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG = 10,
+        IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT = 11,
+        IMAGE_DIRECTORY_ENTRY_IAT = 12, // Import Address Table
+        IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT = 13,
+        IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR = 14,
+    }
+
+    [Flags]
+    internal enum DllCharacteristics : ushort
+    {
+        IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040,
+        IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = 0x0080,
+        IMAGE_DLLCHARACTERISTICS_NX_COMPAT = 0x0100,
+        IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = 0x0200,
+        IMAGE_DLLCHARACTERISTICS_NO_SEH = 0x0400,
+        IMAGE_DLLCHARACTERISTICS_NO_BIND = 0x0800,
+        IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = 0x2000,
+        IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = 0x8000,
+    }
+
+    [Flags]
+    internal enum FileCharacteristics : ushort
+    {
+        IMAGE_FILE_RELOCS_STRIPPED = 0x0001, /* No relocation info */
+        IMAGE_FILE_EXECUTABLE_IMAGE = 0x0002,
+        IMAGE_FILE_LINE_NUMS_STRIPPED = 0x0004,
+        IMAGE_FILE_LOCAL_SYMS_STRIPPED = 0x0008,
+        IMAGE_FILE_AGGRESIVE_WS_TRIM = 0x0010,
+        IMAGE_FILE_LARGE_ADDRESS_AWARE = 0x0020,
+        IMAGE_FILE_16BIT_MACHINE = 0x0040,
+        IMAGE_FILE_BYTES_REVERSED_LO = 0x0080,
+        IMAGE_FILE_32BIT_MACHINE = 0x0100,
+        IMAGE_FILE_DEBUG_STRIPPED = 0x0200,
+        IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = 0x0400,
+        IMAGE_FILE_NET_RUN_FROM_SWAP = 0x0800,
+        IMAGE_FILE_SYSTEM = 0x1000,
+        IMAGE_FILE_DLL = 0x2000,
+        IMAGE_FILE_UP_SYSTEM_ONLY = 0x4000,
+        IMAGE_FILE_BYTES_REVERSED_HI = 0x8000,
+    }
+
+    internal enum MachineSettings : ushort
+    {
+        IMAGE_FILE_MACHINE_UNKNOWN = 0,
+        IMAGE_FILE_MACHINE_TARGET_HOST = 0x0001,
+        IMAGE_FILE_MACHINE_I860 = 0x014d,
+        IMAGE_FILE_MACHINE_I386 = 0x014c,
+        IMAGE_FILE_MACHINE_R3000 = 0x0162,
+        IMAGE_FILE_MACHINE_R4000 = 0x0166,
+        IMAGE_FILE_MACHINE_R10000 = 0x0168,
+        IMAGE_FILE_MACHINE_WCEMIPSV2 = 0x0169,
+        IMAGE_FILE_MACHINE_ALPHA = 0x0184,
+        IMAGE_FILE_MACHINE_SH3 = 0x01a2,
+        IMAGE_FILE_MACHINE_SH3DSP = 0x01a3,
+        IMAGE_FILE_MACHINE_SH3E = 0x01a4,
+        IMAGE_FILE_MACHINE_SH4 = 0x01a6,
+        IMAGE_FILE_MACHINE_SH5 = 0x01a8,
+        IMAGE_FILE_MACHINE_ARM = 0x01c0,
+        IMAGE_FILE_MACHINE_THUMB = 0x01c2,
+        IMAGE_FILE_MACHINE_ARMNT = 0x01c4,
+        IMAGE_FILE_MACHINE_ARM64 = 0xaa64,
+        IMAGE_FILE_MACHINE_AM33 = 0x01d3,
+        IMAGE_FILE_MACHINE_POWERPC = 0x01f0,
+        IMAGE_FILE_MACHINE_POWERPCFP = 0x01f1,
+        IMAGE_FILE_MACHINE_IA64 = 0x0200,
+        IMAGE_FILE_MACHINE_MIPS16 = 0x0266,
+        IMAGE_FILE_MACHINE_ALPHA64 = 0x0284,
+        IMAGE_FILE_MACHINE_MIPSFPU = 0x0366,
+        IMAGE_FILE_MACHINE_MIPSFPU16 = 0x0466,
+        IMAGE_FILE_MACHINE_AXP64 = 0x0284,
+        IMAGE_FILE_MACHINE_TRICORE = 0x0520,
+        IMAGE_FILE_MACHINE_CEF = 0x0cef,
+        IMAGE_FILE_MACHINE_EBC = 0x0ebc,
+        IMAGE_FILE_MACHINE_AMD64 = 0x8664,
+        IMAGE_FILE_MACHINE_M32R = 0x9041,
+        IMAGE_FILE_MACHINE_CEE = 0xc0ee,
+    }
+
+    [Flags]
+    internal enum SectionCharacteristics : uint
+    {
+        IMAGE_SCN_TYPE_REG = 0x00000000, // Reserved
+        IMAGE_SCN_TYPE_DSECT = 0x00000001, // Reserved
+        IMAGE_SCN_TYPE_NOLOAD = 0x00000002, // Reserved
+        IMAGE_SCN_TYPE_GROUP = 0x00000004, // Reserved
+        IMAGE_SCN_TYPE_NO_PAD = 0x00000008, // Reserved
+        IMAGE_SCN_TYPE_COPY = 0x00000010, // Reserved
+
+        IMAGE_SCN_CNT_CODE = 0x00000020,
+        IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040,
+        IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080,
+
+        IMAGE_SCN_LNK_OTHER = 0x00000100,
+        IMAGE_SCN_LNK_INFO = 0x00000200,
+        IMAGE_SCN_TYPE_OVER = 0x00000400, // Reserved
+        IMAGE_SCN_LNK_REMOVE = 0x00000800,
+        IMAGE_SCN_LNK_COMDAT = 0x00001000,
+
+        /* 						0x00002000 - Reserved */
+        IMAGE_SCN_MEM_PROTECTED = 0x00004000, // Obsolete
+        IMAGE_SCN_MEM_FARDATA = 0x00008000,
+
+        IMAGE_SCN_MEM_SYSHEAP = 0x00010000, // Obsolete
+        IMAGE_SCN_MEM_PURGEABLE = 0x00020000,
+        IMAGE_SCN_MEM_16BIT = 0x00020000,
+        IMAGE_SCN_MEM_LOCKED = 0x00040000,
+        IMAGE_SCN_MEM_PRELOAD = 0x00080000,
+
+        IMAGE_SCN_ALIGN_1BYTES = 0x00100000,
+        IMAGE_SCN_ALIGN_2BYTES = 0x00200000,
+        IMAGE_SCN_ALIGN_4BYTES = 0x00300000,
+        IMAGE_SCN_ALIGN_8BYTES = 0x00400000,
+        IMAGE_SCN_ALIGN_16BYTES = 0x00500000, // Default
+        IMAGE_SCN_ALIGN_32BYTES = 0x00600000,
+        IMAGE_SCN_ALIGN_64BYTES = 0x00700000,
+        IMAGE_SCN_ALIGN_128BYTES = 0x00800000,
+        IMAGE_SCN_ALIGN_256BYTES = 0x00900000,
+        IMAGE_SCN_ALIGN_512BYTES = 0x00A00000,
+        IMAGE_SCN_ALIGN_1024BYTES = 0x00B00000,
+        IMAGE_SCN_ALIGN_2048BYTES = 0x00C00000,
+        IMAGE_SCN_ALIGN_4096BYTES = 0x00D00000,
+        IMAGE_SCN_ALIGN_8192BYTES = 0x00E00000,
+        /* 						0x00F00000 - Unused */
+        IMAGE_SCN_ALIGN_MASK = 0x00F00000,
+
+        IMAGE_SCN_LNK_NRELOC_OVFL = 0x01000000,
+
+
+        IMAGE_SCN_MEM_DISCARDABLE = 0x02000000,
+        IMAGE_SCN_MEM_NOT_CACHED = 0x04000000,
+        IMAGE_SCN_MEM_NOT_PAGED = 0x08000000,
+        IMAGE_SCN_MEM_SHARED = 0x10000000,
+        IMAGE_SCN_MEM_EXECUTE = 0x20000000,
+        IMAGE_SCN_MEM_READ = 0x40000000,
+        IMAGE_SCN_MEM_WRITE = 0x80000000,
+    }
+
+    internal enum Subsystem : ushort
+    {
+        IMAGE_SUBSYSTEM_UNKNOWN = 0,
+        IMAGE_SUBSYSTEM_NATIVE = 1,
+        IMAGE_SUBSYSTEM_WINDOWS_GUI = 2, // Windows GUI subsystem
+        IMAGE_SUBSYSTEM_WINDOWS_CUI = 3, // Windows character subsystem
+        IMAGE_SUBSYSTEM_OS2_CUI = 5,
+        IMAGE_SUBSYSTEM_POSIX_CUI = 7,
+        IMAGE_SUBSYSTEM_NATIVE_WINDOWS = 8, // native Win9x driver
+        IMAGE_SUBSYSTEM_WINDOWS_CE_GUI = 9, // Windows CE subsystem
+        IMAGE_SUBSYSTEM_EFI_APPLICATION = 10,
+        IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER = 11,
+        IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER = 12,
+        IMAGE_SUBSYSTEM_EFI_ROM = 13,
+        IMAGE_SUBSYSTEM_XBOX = 14,
+        IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION = 16,
+    }
+
+    internal static class Constants
+    {
+        public const ushort IMAGE_DOS_SIGNATURE = 0x5A4D;     /* MZ   */
+        public const ushort IMAGE_OS2_SIGNATURE = 0x454E;     /* NE   */
+        public const ushort IMAGE_OS2_SIGNATURE_LE = 0x454C;     /* LE   */
+        public const ushort IMAGE_OS2_SIGNATURE_LX = 0x584C;     /* LX */
+        public const ushort IMAGE_VXD_SIGNATURE = 0x454C;     /* LE   */
+        public const uint IMAGE_NT_SIGNATURE = 0x00004550; /* PE00 */
+
+        public const int IMAGE_SIZEOF_FILE_HEADER = 20;
+        public const int IMAGE_SIZEOF_ROM_OPTIONAL_HEADER = 56;
+        public const int IMAGE_SIZEOF_STD_OPTIONAL_HEADER = 28;
+        public const int IMAGE_SIZEOF_NT_OPTIONAL32_HEADER = 224;
+        public const int IMAGE_SIZEOF_NT_OPTIONAL64_HEADER = 240;
+        public const int IMAGE_SIZEOF_SHORT_NAME = 8;
+        public const int IMAGE_SIZEOF_SECTION_HEADER = 40;
+        public const int IMAGE_SIZEOF_SYMBOL = 18;
+        public const int IMAGE_SIZEOF_AUX_SYMBOL = 18;
+        public const int IMAGE_SIZEOF_RELOCATION = 10;
+        public const int IMAGE_SIZEOF_BASE_RELOCATION = 8;
+        public const int IMAGE_SIZEOF_LINENUMBER = 6;
+        public const int IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR = 60;
+
+        // Possible Magic values
+        public const ushort IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10b;
+        public const ushort IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20b;
+        public const ushort IMAGE_ROM_OPTIONAL_HDR_MAGIC = 0x107;
+
+        public const int IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
+    }
+}

BurnOutSharp/ExecutableType/PortableExecutable.cs

@@ -1,438 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BurnOutSharp.ExecutableType
-{
-    internal enum DirectoryEntries
-    {
-        IMAGE_DIRECTORY_ENTRY_EXPORT = 0,
-        IMAGE_DIRECTORY_ENTRY_IMPORT = 1,
-        IMAGE_DIRECTORY_ENTRY_RESOURCE = 2,
-        IMAGE_DIRECTORY_ENTRY_EXCEPTION = 3,
-        IMAGE_DIRECTORY_ENTRY_SECURIT = 4,
-        IMAGE_DIRECTORY_ENTRY_BASERELOC = 5,
-        IMAGE_DIRECTORY_ENTRY_DEBUG = 6,
-        IMAGE_DIRECTORY_ENTRY_COPYRIGHT = 7,
-        IMAGE_DIRECTORY_ENTRY_GLOBALPTR = 8, // (MIPS GP)
-        IMAGE_DIRECTORY_ENTRY_TLS = 9,
-        IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG = 10,
-        IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT = 11,
-        IMAGE_DIRECTORY_ENTRY_IAT = 12, // Import Address Table
-        IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT = 13,
-        IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR = 14,
-    }
-
-    [Flags]
-    internal enum DllCharacteristics : ushort
-    {
-        IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040,
-        IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = 0x0080,
-        IMAGE_DLLCHARACTERISTICS_NX_COMPAT = 0x0100,
-        IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = 0x0200,
-        IMAGE_DLLCHARACTERISTICS_NO_SEH = 0x0400,
-        IMAGE_DLLCHARACTERISTICS_NO_BIND = 0x0800,
-        IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = 0x2000,
-        IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = 0x8000,
-    }
-
-    [Flags]
-    internal enum FileCharacteristics : ushort
-    {
-        IMAGE_FILE_RELOCS_STRIPPED = 0x0001, /* No relocation info */
-        IMAGE_FILE_EXECUTABLE_IMAGE = 0x0002,
-        IMAGE_FILE_LINE_NUMS_STRIPPED = 0x0004,
-        IMAGE_FILE_LOCAL_SYMS_STRIPPED = 0x0008,
-        IMAGE_FILE_AGGRESIVE_WS_TRIM = 0x0010,
-        IMAGE_FILE_LARGE_ADDRESS_AWARE = 0x0020,
-        IMAGE_FILE_16BIT_MACHINE = 0x0040,
-        IMAGE_FILE_BYTES_REVERSED_LO = 0x0080,
-        IMAGE_FILE_32BIT_MACHINE = 0x0100,
-        IMAGE_FILE_DEBUG_STRIPPED = 0x0200,
-        IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = 0x0400,
-        IMAGE_FILE_NET_RUN_FROM_SWAP = 0x0800,
-        IMAGE_FILE_SYSTEM = 0x1000,
-        IMAGE_FILE_DLL = 0x2000,
-        IMAGE_FILE_UP_SYSTEM_ONLY = 0x4000,
-        IMAGE_FILE_BYTES_REVERSED_HI = 0x8000,
-    }
-
-    internal enum MachineSettings : ushort
-    {
-        IMAGE_FILE_MACHINE_UNKNOWN = 0,
-        IMAGE_FILE_MACHINE_TARGET_HOST = 0x0001,
-        IMAGE_FILE_MACHINE_I860 = 0x014d,
-        IMAGE_FILE_MACHINE_I386 = 0x014c,
-        IMAGE_FILE_MACHINE_R3000 = 0x0162,
-        IMAGE_FILE_MACHINE_R4000 = 0x0166,
-        IMAGE_FILE_MACHINE_R10000 = 0x0168,
-        IMAGE_FILE_MACHINE_WCEMIPSV2 = 0x0169,
-        IMAGE_FILE_MACHINE_ALPHA = 0x0184,
-        IMAGE_FILE_MACHINE_SH3 = 0x01a2,
-        IMAGE_FILE_MACHINE_SH3DSP = 0x01a3,
-        IMAGE_FILE_MACHINE_SH3E = 0x01a4,
-        IMAGE_FILE_MACHINE_SH4 = 0x01a6,
-        IMAGE_FILE_MACHINE_SH5 = 0x01a8,
-        IMAGE_FILE_MACHINE_ARM = 0x01c0,
-        IMAGE_FILE_MACHINE_THUMB = 0x01c2,
-        IMAGE_FILE_MACHINE_ARMNT = 0x01c4,
-        IMAGE_FILE_MACHINE_ARM64 = 0xaa64,
-        IMAGE_FILE_MACHINE_AM33 = 0x01d3,
-        IMAGE_FILE_MACHINE_POWERPC = 0x01f0,
-        IMAGE_FILE_MACHINE_POWERPCFP = 0x01f1,
-        IMAGE_FILE_MACHINE_IA64 = 0x0200,
-        IMAGE_FILE_MACHINE_MIPS16 = 0x0266,
-        IMAGE_FILE_MACHINE_ALPHA64 = 0x0284,
-        IMAGE_FILE_MACHINE_MIPSFPU = 0x0366,
-        IMAGE_FILE_MACHINE_MIPSFPU16 = 0x0466,
-        IMAGE_FILE_MACHINE_AXP64 = 0x0284,
-        IMAGE_FILE_MACHINE_TRICORE = 0x0520,
-        IMAGE_FILE_MACHINE_CEF = 0x0cef,
-        IMAGE_FILE_MACHINE_EBC = 0x0ebc,
-        IMAGE_FILE_MACHINE_AMD64 = 0x8664,
-        IMAGE_FILE_MACHINE_M32R = 0x9041,
-        IMAGE_FILE_MACHINE_CEE = 0xc0ee,
-    }
-
-    [Flags]
-    internal enum SectionCharacteristics : uint
-    {
-        IMAGE_SCN_TYPE_REG = 0x00000000, // Reserved
-        IMAGE_SCN_TYPE_DSECT = 0x00000001, // Reserved
-        IMAGE_SCN_TYPE_NOLOAD = 0x00000002, // Reserved
-        IMAGE_SCN_TYPE_GROUP = 0x00000004, // Reserved
-        IMAGE_SCN_TYPE_NO_PAD = 0x00000008, // Reserved
-        IMAGE_SCN_TYPE_COPY = 0x00000010, // Reserved
-
-        IMAGE_SCN_CNT_CODE = 0x00000020,
-        IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040,
-        IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080,
-
-        IMAGE_SCN_LNK_OTHER = 0x00000100,
-        IMAGE_SCN_LNK_INFO = 0x00000200,
-        IMAGE_SCN_TYPE_OVER = 0x00000400, // Reserved
-        IMAGE_SCN_LNK_REMOVE = 0x00000800,
-        IMAGE_SCN_LNK_COMDAT = 0x00001000,
-
-        /* 						0x00002000 - Reserved */
-        IMAGE_SCN_MEM_PROTECTED = 0x00004000, // Obsolete
-        IMAGE_SCN_MEM_FARDATA = 0x00008000,
-
-        IMAGE_SCN_MEM_SYSHEAP = 0x00010000, // Obsolete
-        IMAGE_SCN_MEM_PURGEABLE = 0x00020000,
-        IMAGE_SCN_MEM_16BIT = 0x00020000,
-        IMAGE_SCN_MEM_LOCKED = 0x00040000,
-        IMAGE_SCN_MEM_PRELOAD = 0x00080000,
-
-        IMAGE_SCN_ALIGN_1BYTES = 0x00100000,
-        IMAGE_SCN_ALIGN_2BYTES = 0x00200000,
-        IMAGE_SCN_ALIGN_4BYTES = 0x00300000,
-        IMAGE_SCN_ALIGN_8BYTES = 0x00400000,
-        IMAGE_SCN_ALIGN_16BYTES = 0x00500000, // Default
-        IMAGE_SCN_ALIGN_32BYTES = 0x00600000,
-        IMAGE_SCN_ALIGN_64BYTES = 0x00700000,
-        IMAGE_SCN_ALIGN_128BYTES = 0x00800000,
-        IMAGE_SCN_ALIGN_256BYTES = 0x00900000,
-        IMAGE_SCN_ALIGN_512BYTES = 0x00A00000,
-        IMAGE_SCN_ALIGN_1024BYTES = 0x00B00000,
-        IMAGE_SCN_ALIGN_2048BYTES = 0x00C00000,
-        IMAGE_SCN_ALIGN_4096BYTES = 0x00D00000,
-        IMAGE_SCN_ALIGN_8192BYTES = 0x00E00000,
-        /* 						0x00F00000 - Unused */
-        IMAGE_SCN_ALIGN_MASK = 0x00F00000,
-
-        IMAGE_SCN_LNK_NRELOC_OVFL = 0x01000000,
-
-
-        IMAGE_SCN_MEM_DISCARDABLE = 0x02000000,
-        IMAGE_SCN_MEM_NOT_CACHED = 0x04000000,
-        IMAGE_SCN_MEM_NOT_PAGED = 0x08000000,
-        IMAGE_SCN_MEM_SHARED = 0x10000000,
-        IMAGE_SCN_MEM_EXECUTE = 0x20000000,
-        IMAGE_SCN_MEM_READ = 0x40000000,
-        IMAGE_SCN_MEM_WRITE = 0x80000000,
-    }
-
-    internal enum Subsystem : ushort
-    {
-        IMAGE_SUBSYSTEM_UNKNOWN = 0,
-        IMAGE_SUBSYSTEM_NATIVE = 1,
-        IMAGE_SUBSYSTEM_WINDOWS_GUI = 2, // Windows GUI subsystem
-        IMAGE_SUBSYSTEM_WINDOWS_CUI = 3, // Windows character subsystem
-        IMAGE_SUBSYSTEM_OS2_CUI = 5,
-        IMAGE_SUBSYSTEM_POSIX_CUI = 7,
-        IMAGE_SUBSYSTEM_NATIVE_WINDOWS = 8, // native Win9x driver
-        IMAGE_SUBSYSTEM_WINDOWS_CE_GUI = 9, // Windows CE subsystem
-        IMAGE_SUBSYSTEM_EFI_APPLICATION = 10,
-        IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER = 11,
-        IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER = 12,
-        IMAGE_SUBSYSTEM_EFI_ROM = 13,
-        IMAGE_SUBSYSTEM_XBOX = 14,
-        IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION = 16,
-    }
-
-    internal static class Constants
-    {
-        public const ushort IMAGE_DOS_SIGNATURE = 0x5A4D;     /* MZ   */
-        public const ushort IMAGE_OS2_SIGNATURE = 0x454E;     /* NE   */
-        public const ushort IMAGE_OS2_SIGNATURE_LE = 0x454C;     /* LE   */
-        public const ushort IMAGE_OS2_SIGNATURE_LX = 0x584C;     /* LX */
-        public const ushort IMAGE_VXD_SIGNATURE = 0x454C;     /* LE   */
-        public const uint IMAGE_NT_SIGNATURE = 0x00004550; /* PE00 */
-
-        public const int IMAGE_SIZEOF_FILE_HEADER = 20;
-        public const int IMAGE_SIZEOF_ROM_OPTIONAL_HEADER = 56;
-        public const int IMAGE_SIZEOF_STD_OPTIONAL_HEADER = 28;
-        public const int IMAGE_SIZEOF_NT_OPTIONAL32_HEADER = 224;
-        public const int IMAGE_SIZEOF_NT_OPTIONAL64_HEADER = 240;
-        public const int IMAGE_SIZEOF_SHORT_NAME = 8;
-        public const int IMAGE_SIZEOF_SECTION_HEADER = 40;
-        public const int IMAGE_SIZEOF_SYMBOL = 18;
-        public const int IMAGE_SIZEOF_AUX_SYMBOL = 18;
-        public const int IMAGE_SIZEOF_RELOCATION = 10;
-        public const int IMAGE_SIZEOF_BASE_RELOCATION = 8;
-        public const int IMAGE_SIZEOF_LINENUMBER = 6;
-        public const int IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR = 60;
-
-        // Possible Magic values
-        public const ushort IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10b;
-        public const ushort IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20b;
-        public const ushort IMAGE_ROM_OPTIONAL_HDR_MAGIC = 0x107;
-
-        public const int IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
-    }
-
-    internal class IMAGE_DOS_HEADER
-    {
-        ushort e_magic;      /* 00: MZ Header signature */
-        ushort e_cblp;       /* 02: Bytes on last page of file */
-        ushort e_cp;         /* 04: Pages in file */
-        ushort e_crlc;       /* 06: Relocations */
-        ushort e_cparhdr;    /* 08: Size of header in paragraphs */
-        ushort e_minalloc;   /* 0a: Minimum extra paragraphs needed */
-        ushort e_maxalloc;   /* 0c: Maximum extra paragraphs needed */
-        ushort e_ss;         /* 0e: Initial (relative) SS value */
-        ushort e_sp;         /* 10: Initial SP value */
-        ushort e_csum;       /* 12: Checksum */
-        ushort e_ip;         /* 14: Initial IP value */
-        ushort e_cs;         /* 16: Initial (relative) CS value */
-        ushort e_lfarlc;     /* 18: File address of relocation table */
-        ushort e_ovno;       /* 1a: Overlay number */
-        ushort[] e_res;      /* 1c: Reserved words [4] */
-        ushort e_oemid;      /* 24: OEM identifier (for e_oeminfo) */
-        ushort e_oeminfo;    /* 26: OEM information; e_oemid specific */
-        ushort[] e_res2;     /* 28: Reserved words [10] */
-        uint e_lfanew;       /* 3c: Offset to extended header */
-    }
-
-    internal class IMAGE_OS2_HEADER
-    {
-        ushort ne_magic;           /* 00 NE signature 'NE' */
-        byte ne_ver;               /* 02 Linker version number */
-        byte ne_rev;               /* 03 Linker revision number */
-        ushort ne_enttab;          /* 04 Offset to entry table relative to NE */
-        ushort ne_cbenttab;        /* 06 Length of entry table in bytes */
-        uint ne_crc;               /* 08 Checksum */
-        ushort ne_flags;           /* 0c Flags about segments in this file */
-        ushort ne_autodata;        /* 0e Automatic data segment number */
-        ushort ne_heap;            /* 10 Initial size of local heap */
-        ushort ne_stack;           /* 12 Initial size of stack */
-        uint ne_csip;              /* 14 Initial CS:IP */
-        uint ne_sssp;              /* 18 Initial SS:SP */
-        ushort ne_cseg;            /* 1c # of entries in segment table */
-        ushort ne_cmod;            /* 1e # of entries in module reference tab. */
-        ushort ne_cbnrestab;       /* 20 Length of nonresident-name table     */
-        ushort ne_segtab;          /* 22 Offset to segment table */
-        ushort ne_rsrctab;         /* 24 Offset to resource table */
-        ushort ne_restab;          /* 26 Offset to resident-name table */
-        ushort ne_modtab;          /* 28 Offset to module reference table */
-        ushort ne_imptab;          /* 2a Offset to imported name table */
-        uint ne_nrestab;           /* 2c Offset to nonresident-name table */
-        ushort ne_cmovent;         /* 30 # of movable entry points */
-        ushort ne_align;           /* 32 Logical sector alignment shift count */
-        ushort ne_cres;            /* 34 # of resource segments */
-        byte ne_exetyp;            /* 36 Flags indicating target OS */
-        byte ne_flagsothers;       /* 37 Additional information flags */
-        ushort ne_pretthunks;      /* 38 Offset to return thunks */
-        ushort ne_psegrefbytes;    /* 3a Offset to segment ref. bytes */
-        ushort ne_swaparea;        /* 3c Reserved by Microsoft */
-        ushort ne_expver;          /* 3e Expected Windows version number */
-    }
-
-    internal class IMAGE_VXD_HEADER
-    {
-        ushort e32_magic;
-        byte e32_border;
-        byte e32_worder;
-        uint e32_level;
-        ushort e32_cpu;
-        ushort e32_os;
-        uint e32_ver;
-        uint e32_mflags;
-        uint e32_mpages;
-        uint e32_startobj;
-        uint e32_eip;
-        uint e32_stackobj;
-        uint e32_esp;
-        uint e32_pagesize;
-        uint e32_lastpagesize;
-        uint e32_fixupsize;
-        uint e32_fixupsum;
-        uint e32_ldrsize;
-        uint e32_ldrsum;
-        uint e32_objtab;
-        uint e32_objcnt;
-        uint e32_objmap;
-        uint e32_itermap;
-        uint e32_rsrctab;
-        uint e32_rsrccnt;
-        uint e32_restab;
-        uint e32_enttab;
-        uint e32_dirtab;
-        uint e32_dircnt;
-        uint e32_fpagetab;
-        uint e32_frectab;
-        uint e32_impmod;
-        uint e32_impmodcnt;
-        uint e32_impproc;
-        uint e32_pagesum;
-        uint e32_datapage;
-        uint e32_preload;
-        uint e32_nrestab;
-        uint e32_cbnrestab;
-        uint e32_nressum;
-        uint e32_autodata;
-        uint e32_debuginfo;
-        uint e32_debuglen;
-        uint e32_instpreload;
-        uint e32_instdemand;
-        uint e32_heapsize;
-        byte[] e32_res3; // [12]
-        uint e32_winresoff;
-        uint e32_winreslen;
-        ushort e32_devid;
-        ushort e32_ddkver;
-    }
-
-    internal class IMAGE_FILE_HEADER
-    {
-        ushort Machine;
-        ushort NumberOfSections;
-        uint TimeDateStamp;
-        uint PointerToSymbolTable;
-        uint NumberOfSymbols;
-        ushort SizeOfOptionalHeader;
-        ushort Characteristics;
-    }
-
-    internal class IMAGE_DATA_DIRECTORY
-    {
-        uint VirtualAddress;
-        uint Size;
-    }
-
-    internal class IMAGE_OPTIONAL_HEADER64
-    {
-        ushort Magic; /* 0x20b */
-        byte MajorLinkerVersion;
-        byte MinorLinkerVersion;
-        uint SizeOfCode;
-        uint SizeOfInitializedData;
-        uint SizeOfUninitializedData;
-        uint AddressOfEntryPoint;
-        uint BaseOfCode;
-        ulong ImageBase;
-        uint SectionAlignment;
-        uint FileAlignment;
-        ushort MajorOperatingSystemVersion;
-        ushort MinorOperatingSystemVersion;
-        ushort MajorImageVersion;
-        ushort MinorImageVersion;
-        ushort MajorSubsystemVersion;
-        ushort MinorSubsystemVersion;
-        uint Win32VersionValue;
-        uint SizeOfImage;
-        uint SizeOfHeaders;
-        uint CheckSum;
-        ushort Subsystem;
-        ushort DllCharacteristics;
-        ulong SizeOfStackReserve;
-        ulong SizeOfStackCommit;
-        ulong SizeOfHeapReserve;
-        ulong SizeOfHeapCommit;
-        uint LoaderFlags;
-        uint NumberOfRvaAndSizes;
-        IMAGE_DATA_DIRECTORY[] DataDirectory; // [IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
-    }
-
-    internal class IMAGE_NT_HEADERS64
-    {
-        uint Signature;
-        IMAGE_FILE_HEADER FileHeader;
-        IMAGE_OPTIONAL_HEADER64 OptionalHeader;
-    }
-
-    internal class IMAGE_OPTIONAL_HEADER32
-    {
-        /* Standard fields */
-
-        ushort Magic; /* 0x10b or 0x107 */    /* 0x00 */
-        byte MajorLinkerVersion;
-        byte MinorLinkerVersion;
-        uint SizeOfCode;
-        uint SizeOfInitializedData;
-        uint SizeOfUninitializedData;
-        uint AddressOfEntryPoint;      /* 0x10 */
-        uint BaseOfCode;
-        uint BaseOfData;
-
-        /* NT additional fields */
-
-        uint ImageBase;
-        uint SectionAlignment;     /* 0x20 */
-        uint FileAlignment;
-        ushort MajorOperatingSystemVersion;
-        ushort MinorOperatingSystemVersion;
-        ushort MajorImageVersion;
-        ushort MinorImageVersion;
-        ushort MajorSubsystemVersion;     /* 0x30 */
-        ushort MinorSubsystemVersion;
-        uint Win32VersionValue;
-        uint SizeOfImage;
-        uint SizeOfHeaders;
-        uint CheckSum;         /* 0x40 */
-        ushort Subsystem;
-        ushort DllCharacteristics;
-        uint SizeOfStackReserve;
-        uint SizeOfStackCommit;
-        uint SizeOfHeapReserve;        /* 0x50 */
-        uint SizeOfHeapCommit;
-        uint LoaderFlags;
-        uint NumberOfRvaAndSizes;
-        IMAGE_DATA_DIRECTORY[] DataDirectory; /* 0x60, [IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
-        /* 0xE0 */
-    }
-
-    internal class IMAGE_NT_HEADERS32
-    {
-        uint Signature; /* "PE"\0\0 */   /* 0x00 */
-        IMAGE_FILE_HEADER FileHeader;       /* 0x04 */
-        IMAGE_OPTIONAL_HEADER32 OptionalHeader;	/* 0x18 */
-    }
-
-    internal class IMAGE_SECTION_HEADER
-    {
-        byte[] Name; // [IMAGE_SIZEOF_SHORT_NAME];
-        uint PhysicalAddressOrVirtualSize; // Misc
-        uint VirtualAddress;
-        uint SizeOfRawData;
-        uint PointerToRawData;
-        uint PointerToRelocations;
-        uint PointerToLinenumbers;
-        ushort NumberOfRelocations;
-        ushort NumberOfLinenumbers;
-        uint Characteristics;
-    }
-}

BurnOutSharp/FileType/MPQ.cs

@@ -26,17 +26,25 @@ namespace BurnOutSharp.FileType
 
                 using (MpqArchive mpqArchive = new MpqArchive(file, FileAccess.Read))
                 {
+                    // Try to open the listfile
                     string listfile = null;
                     MpqFileStream listStream = mpqArchive.OpenFile("(listfile)");
-                    bool canRead = listStream.CanRead;
+                   
+                    // If we can't read the listfile, we just return
+                    if (!listStream.CanRead)
+                        return null;
 
+                    // Read the listfile in for processing
                     using (StreamReader sr = new StreamReader(listStream))
                     {
                         listfile = sr.ReadToEnd();
                     }
 
-                    string sub = string.Empty;
-                    while ((sub = listfile) != null)
+                    // Split the listfile by newlines
+                    string[] listfileLines = listfile.Replace("\r\n", "\n").Split('\n');
+
+                    // Loop over each entry
+                    foreach (string sub in listfileLines)
                     {
                         // If an individual entry fails
                         try

BurnOutSharp/ProtectionProgress.cs

@@ -1,12 +1,12 @@
 namespace BurnOutSharp
 {
-    public class FileProtection
+    public class ProtectionProgress
     {
         public string Filename { get; private set; }
         public float Percentage { get; private set; }
         public string Protection { get; private set; }
 
-        public FileProtection(string filename, float percentage, string protection)
+        public ProtectionProgress(string filename, float percentage, string protection)
         {
             this.Filename = filename;
             this.Percentage = percentage;

BurnOutSharp/ProtectionType/ProtectDisc.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Diagnostics;
+using System.IO;
 using System.Linq;
+using System.Threading;
 
 namespace BurnOutSharp.ProtectionType
 {
@@ -11,7 +14,7 @@ namespace BurnOutSharp.ProtectionType
             byte[] check = new byte[] { 0x48, 0xFA, 0x4D, 0x45, 0x54, 0x49, 0x4E, 0x46 };
             if (fileContent.Contains(check, out int position))
             {
-                string version = EVORE.SearchProtectDiscVersion(file, fileContent);
+                string version = SearchProtectDiscVersion(file, fileContent);
                 if (version.Length > 0)
                 {
                     string[] astrVersionArray = version.Split('.');
@@ -31,7 +34,7 @@ namespace BurnOutSharp.ProtectionType
             check = new byte[] { 0x41, 0x43, 0x45, 0x2D, 0x50, 0x43, 0x44 };
             if (fileContent.Contains(check, out position))
             {
-                string version = EVORE.SearchProtectDiscVersion(file, fileContent);
+                string version = SearchProtectDiscVersion(file, fileContent);
                 if (version.Length > 0)
                 {
                     string[] astrVersionArray = version.Split('.');
@@ -168,5 +171,166 @@ namespace BurnOutSharp.ProtectionType
 
             return "";
         }
+    
+        // TODO: Analyze this method and figure out if this can be done without attempting execution
+        private static string SearchProtectDiscVersion(string file, byte[] fileContent)
+        {
+            string version = "";
+            DateTime timestart;
+            if (!EVORE.IsEXE(fileContent))
+                return "";
+
+            string tempexe = EVORE.MakeTempFile(fileContent);
+            string[] DependentDlls = EVORE.CopyDependentDlls(file, fileContent);
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
+            }
+            catch { }
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
+            }
+            catch { }
+            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+            {
+                try
+                {
+                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
+                }
+                catch { }
+            }
+
+            Process exe = EVORE.StartSafe(tempexe);
+            if (exe == null)
+                return "";
+
+            Process[] processes = new Process[0];
+            timestart = DateTime.Now;
+            do
+            {
+                exe.Refresh();
+                string[] files = null;
+
+                //check for ProtectDisc 8.2-x
+                if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+                {
+                    files = Directory.GetFiles(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc"), "p*.dll");
+                }
+
+                if (files != null)
+                {
+                    if (files.Length > 0)
+                    {
+                        FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
+                        if (fvinfo.FileVersion != "")
+                        {
+                            version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
+                            //ProtectDisc 9 uses a ProtectDisc-Core dll version 8.0.x
+                            if (version.StartsWith("8.0"))
+                                version = "";
+                            fvinfo = null;
+                            break;
+                        }
+                    }
+                }
+
+                //check for ProtectDisc 7.1-8.1
+                files = Directory.GetFiles(Path.GetTempPath(), "a*.tmp");
+                if (files.Length > 0)
+                {
+                    FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
+                    if (fvinfo.FileVersion != "")
+                    {
+                        version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
+                        fvinfo = null;
+                        break;
+                    }
+                }
+
+                if (exe.HasExited)
+                    break;
+
+                processes = Process.GetProcessesByName(exe.ProcessName);
+                if (processes.Length == 2)
+                {
+                    processes[0].Refresh();
+                    processes[1].Refresh();
+                    if (processes[1].WorkingSet64 > exe.WorkingSet64)
+                        exe = processes[1];
+                    else if (processes[0].WorkingSet64 > exe.WorkingSet64) //else if (processes[0].Modules.Count > exe.Modules.Count)
+                        exe = processes[0];
+                }
+            } while (processes.Length > 0 && DateTime.Now.Subtract(timestart).TotalSeconds < 20);
+
+            Thread.Sleep(500);
+            if (!exe.HasExited)
+            {
+                processes = Process.GetProcessesByName(exe.ProcessName);
+                if (processes.Length == 2)
+                {
+                    try
+                    {
+                        processes[0].Kill();
+                    }
+                    catch { }
+                    processes[0].Close();
+                    try
+                    {
+                        processes[1].Kill();
+                    }
+                    catch { }
+                }
+                else
+                {
+                    exe.Refresh();
+                    try
+                    {
+                        exe.Kill();
+                    }
+                    catch { }
+                }
+            }
+
+            exe.Close();
+            Thread.Sleep(500);
+            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+            {
+                try
+                {
+                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
+                }
+                catch { }
+            }
+
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
+            }
+            catch { }
+
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
+            }
+            catch { }
+            File.Delete(tempexe);
+            if (DependentDlls != null)
+            {
+                for (int i = 0; i < DependentDlls.Length; i++)
+                {
+                    try
+                    {
+                        File.Delete(DependentDlls[i]);
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine("!error while deleting file " + DependentDlls[i] + "; " + ex.Message);
+                    }
+                }
+            }
+
+            return version;
+        }
     }
 }

BurnOutSharp/ProtectionType/SafeDisc.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Text;
 
 namespace BurnOutSharp.ProtectionType
 {
@@ -25,7 +27,7 @@ namespace BurnOutSharp.ProtectionType
             check = new byte[] { 0x00, 0x00, 0x42, 0x6F, 0x47, 0x5F };
             if (fileContent.Contains(check, out position))
             {
-                string version = EVORE.SearchSafeDiscVersion(file, fileContent);
+                string version = SearchSafeDiscVersion(file, fileContent);
                 if (version.Length > 0)
                     return $"SafeDisc {version}" + (includePosition ? $" (Index {position})" : string.Empty);
 
@@ -36,7 +38,7 @@ namespace BurnOutSharp.ProtectionType
             check = new byte[] { 0x73, 0x74, 0x78, 0x74, 0x37, 0x37, 0x34 };
             if (fileContent.Contains(check, out position))
             {
-                string version = EVORE.SearchSafeDiscVersion(file, fileContent);
+                string version = SearchSafeDiscVersion(file, fileContent);
                 if (version.Length > 0)
                     return $"SafeDisc {version}" + (includePosition ? $" (Index {position})" : string.Empty);
 
@@ -47,7 +49,7 @@ namespace BurnOutSharp.ProtectionType
             check = new byte[] { 0x73, 0x74, 0x78, 0x74, 0x33, 0x37, 0x31 };
             if (fileContent.Contains(check, out position))
             {
-                string version = EVORE.SearchSafeDiscVersion(file, fileContent);
+                string version = SearchSafeDiscVersion(file, fileContent);
                 if (version.Length > 0)
                     return $"SafeDisc {version}" + (includePosition ? $" (Index {position})" : string.Empty);
 
@@ -239,5 +241,89 @@ namespace BurnOutSharp.ProtectionType
 
             return $"{version}.{subVersion:00}.{subsubVersion:000}";
         }
+    
+        // TODO: Analyze this method and figure out if this can be done without attempting execution
+        private static string SearchSafeDiscVersion(string file, byte[] fileContent)
+        {
+            Process exe;
+            string version = "";
+            DateTime timestart;
+            if (!EVORE.IsEXE(fileContent))
+                return "";
+
+            string tempexe = EVORE.MakeTempFile(fileContent);
+            string[] DependentDlls = EVORE.CopyDependentDlls(file, fileContent);
+            try
+            {
+                Directory.Delete(Path.Combine(Path.GetTempPath(), "~e*"), true);
+            }
+            catch { }
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "~e*"));
+            }
+            catch { }
+
+            exe = EVORE.StartSafe(tempexe);
+            if (exe == null)
+                return "";
+
+            timestart = DateTime.Now;
+            do
+            {
+                if (Directory.GetDirectories(Path.GetTempPath(), "~e*").Length > 0)
+                {
+                    string[] files = Directory.GetFiles(Directory.GetDirectories(Path.GetTempPath(), "~e*")[0], "~de*.tmp");
+                    if (files.Length > 0)
+                    {
+                        StreamReader sr;
+                        try
+                        {
+                            sr = new StreamReader(files[0], Encoding.Default);
+                            string FileContent = sr.ReadToEnd();
+                            sr.Close();
+                            int position = FileContent.IndexOf("%ld.%ld.%ld, %ld, %s,") - 1;
+                            if (position > -1)
+                                version = FileContent.Substring(position + 28, 12);
+                            break;
+                        }
+                        catch { }
+                    }
+                }
+            } while (!exe.HasExited && DateTime.Now.Subtract(timestart).TotalSeconds < 20);
+
+            if (!exe.HasExited)
+                exe.Kill();
+            exe.Close();
+
+            try
+            {
+                Directory.Delete(Path.Combine(Path.GetTempPath(), "~e*"), true);
+            }
+            catch { }
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "~e*"));
+                File.Delete(tempexe);
+            }
+            catch { }
+
+            if (DependentDlls != null)
+            {
+                for (int i = 0; i < DependentDlls.Length; i--)
+                {
+                    try
+                    {
+                        File.Delete(DependentDlls[i]);
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine("!error while deleting file " + DependentDlls[i] + "; " + ex.Message);
+                    }
+                }
+            }
+
+            return version;
+        }
     }
 }

BurnOutSharp/ProtectionType/VOBProtectCDDVD.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Threading;
 
 namespace BurnOutSharp.ProtectionType
 {
@@ -22,7 +24,7 @@ namespace BurnOutSharp.ProtectionType
                 if (version.Length > 0)
                     return $"VOB ProtectCD/DVD {version}" + (includePosition ? $" (Index {position})" : string.Empty);
 
-                version = EVORE.SearchProtectDiscVersion(file, fileContent);
+                version = SearchProtectDiscVersion(file, fileContent);
                 if (version.Length > 0)
                 {
                     if (version.StartsWith("2"))
@@ -89,5 +91,166 @@ namespace BurnOutSharp.ProtectionType
 
             return "";
         }
+    
+        // TODO: Analyze this method and figure out if this can be done without attempting execution
+        private static string SearchProtectDiscVersion(string file, byte[] fileContent)
+        {
+            string version = "";
+            DateTime timestart;
+            if (!EVORE.IsEXE(fileContent))
+                return "";
+
+            string tempexe = EVORE.MakeTempFile(fileContent);
+            string[] DependentDlls = EVORE.CopyDependentDlls(file, fileContent);
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
+            }
+            catch { }
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
+            }
+            catch { }
+            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+            {
+                try
+                {
+                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
+                }
+                catch { }
+            }
+
+            Process exe = EVORE.StartSafe(tempexe);
+            if (exe == null)
+                return "";
+
+            Process[] processes = new Process[0];
+            timestart = DateTime.Now;
+            do
+            {
+                exe.Refresh();
+                string[] files = null;
+
+                //check for ProtectDisc 8.2-x
+                if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+                {
+                    files = Directory.GetFiles(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc"), "p*.dll");
+                }
+
+                if (files != null)
+                {
+                    if (files.Length > 0)
+                    {
+                        FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
+                        if (fvinfo.FileVersion != "")
+                        {
+                            version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
+                            //ProtectDisc 9 uses a ProtectDisc-Core dll version 8.0.x
+                            if (version.StartsWith("8.0"))
+                                version = "";
+                            fvinfo = null;
+                            break;
+                        }
+                    }
+                }
+
+                //check for ProtectDisc 7.1-8.1
+                files = Directory.GetFiles(Path.GetTempPath(), "a*.tmp");
+                if (files.Length > 0)
+                {
+                    FileVersionInfo fvinfo = FileVersionInfo.GetVersionInfo(files[0]);
+                    if (fvinfo.FileVersion != "")
+                    {
+                        version = fvinfo.FileVersion.Replace(" ", "").Replace(",", ".");
+                        fvinfo = null;
+                        break;
+                    }
+                }
+
+                if (exe.HasExited)
+                    break;
+
+                processes = Process.GetProcessesByName(exe.ProcessName);
+                if (processes.Length == 2)
+                {
+                    processes[0].Refresh();
+                    processes[1].Refresh();
+                    if (processes[1].WorkingSet64 > exe.WorkingSet64)
+                        exe = processes[1];
+                    else if (processes[0].WorkingSet64 > exe.WorkingSet64) //else if (processes[0].Modules.Count > exe.Modules.Count)
+                        exe = processes[0];
+                }
+            } while (processes.Length > 0 && DateTime.Now.Subtract(timestart).TotalSeconds < 20);
+
+            Thread.Sleep(500);
+            if (!exe.HasExited)
+            {
+                processes = Process.GetProcessesByName(exe.ProcessName);
+                if (processes.Length == 2)
+                {
+                    try
+                    {
+                        processes[0].Kill();
+                    }
+                    catch { }
+                    processes[0].Close();
+                    try
+                    {
+                        processes[1].Kill();
+                    }
+                    catch { }
+                }
+                else
+                {
+                    exe.Refresh();
+                    try
+                    {
+                        exe.Kill();
+                    }
+                    catch { }
+                }
+            }
+
+            exe.Close();
+            Thread.Sleep(500);
+            if (Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc")))
+            {
+                try
+                {
+                    File.Delete(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ProtectDisc", "p*.dll"));
+                }
+                catch { }
+            }
+
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "a*.tmp"));
+            }
+            catch { }
+
+            try
+            {
+                File.Delete(Path.Combine(Path.GetTempPath(), "PCD*.sys"));
+            }
+            catch { }
+            File.Delete(tempexe);
+            if (DependentDlls != null)
+            {
+                for (int i = 0; i < DependentDlls.Length; i++)
+                {
+                    try
+                    {
+                        File.Delete(DependentDlls[i]);
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine("!error while deleting file " + DependentDlls[i] + "; " + ex.Message);
+                    }
+                }
+            }
+
+            return version;
+        }
     }
 }

BurnOutSharp/Scanner.cs

@@ -12,7 +12,7 @@ namespace BurnOutSharp
         /// <summary>
         /// Optional progress callback during scanning
         /// </summary>
-        public IProgress<FileProtection> FileProgress { get; set; } = null;
+        public IProgress<ProtectionProgress> FileProgress { get; set; } = null;
 
         /// <summary>
         /// Determines whether the byte position of found protection is included or not
@@ -38,7 +38,7 @@ namespace BurnOutSharp
         /// Constructor
         /// </summary>
         /// <param name="fileProgress">Optional progress callback</param>
-        public Scanner(IProgress<FileProtection> fileProgress = null)
+        public Scanner(IProgress<ProtectionProgress> fileProgress = null)
         {
             FileProgress = fileProgress;
         }
@@ -64,7 +64,7 @@ namespace BurnOutSharp
                 return null;
 
             // Checkpoint
-            FileProgress?.Report(new FileProtection(null, 0, null));
+            FileProgress?.Report(new ProtectionProgress(null, 0, null));
 
             // Temp variables for reporting
             string tempFilePath = Path.GetTempPath();
@@ -96,7 +96,7 @@ namespace BurnOutSharp
                             reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);
 
                         // Checkpoint
-                        FileProgress?.Report(new FileProtection(reportableFileName, i / (float)files.Count(), "Checking file" + (file != reportableFileName ? " from archive" : string.Empty)));
+                        FileProgress?.Report(new ProtectionProgress(reportableFileName, i / (float)files.Count(), "Checking file" + (file != reportableFileName ? " from archive" : string.Empty)));
 
                         // Scan for path-detectable protections
                         var filePathProtections = GetPathProtections(file);
@@ -118,7 +118,7 @@ namespace BurnOutSharp
                         // Checkpoint
                         protections.TryGetValue(file, out List<string> fullProtectionList);
                         string fullProtection = (fullProtectionList != null && fullProtectionList.Any() ? string.Join(", ", fullProtectionList) : null);
-                        FileProgress?.Report(new FileProtection(reportableFileName, (i + 1) / (float)files.Count(), fullProtection ?? string.Empty));
+                        FileProgress?.Report(new ProtectionProgress(reportableFileName, (i + 1) / (float)files.Count(), fullProtection ?? string.Empty));
                     }
                 }
 
@@ -131,7 +131,7 @@ namespace BurnOutSharp
                         reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);
 
                     // Checkpoint
-                    FileProgress?.Report(new FileProtection(reportableFileName, 0, "Checking file" + (path != reportableFileName ? " from archive" : string.Empty)));
+                    FileProgress?.Report(new ProtectionProgress(reportableFileName, 0, "Checking file" + (path != reportableFileName ? " from archive" : string.Empty)));
 
                     // Scan for path-detectable protections
                     var filePathProtections = GetPathProtections(path);
@@ -153,7 +153,7 @@ namespace BurnOutSharp
                     // Checkpoint
                     protections.TryGetValue(path, out List<string> fullProtectionList);
                     string fullProtection = (fullProtectionList != null && fullProtectionList.Any() ? string.Join(", ", fullProtectionList) : null);
-                    FileProgress?.Report(new FileProtection(reportableFileName, 1, fullProtection ?? string.Empty));
+                    FileProgress?.Report(new ProtectionProgress(reportableFileName, 1, fullProtection ?? string.Empty));
                 }
 
                 // Throw on an invalid path

Test/Program.cs

@@ -10,7 +10,7 @@ namespace Test
         static void Main(string[] args)
         {
             // Create progress indicator
-            var p = new Progress<FileProtection>();
+            var p = new Progress<ProtectionProgress>();
             p.ProgressChanged += Changed;
 
             // Create scanner to be shared
@@ -24,26 +24,36 @@ namespace Test
 
             foreach (string arg in args)
             {
-                var protections = scanner.GetProtections(arg);
-                if (protections != null)
+                try
                 {
-                    using (StreamWriter sw = new StreamWriter(File.OpenWrite($"{DateTime.Now:yyyy-MM-dd_HHmmss}.txt")))
+                    var protections = scanner.GetProtections(arg);
+                    if (protections != null)
                     {
-                        foreach (string key in protections.Keys)
+                        using (StreamWriter sw = new StreamWriter(File.OpenWrite($"{DateTime.Now:yyyy-MM-dd_HHmmss}.txt")))
                         {
-                            // Skip over files with no protection
-                            if (protections[key] == null || !protections[key].Any())
-                                continue;
+                            foreach (string key in protections.Keys)
+                            {
+                                // Skip over files with no protection
+                                if (protections[key] == null || !protections[key].Any())
+                                    continue;
 
-                            string line = $"{key}: {string.Join(", ", protections[key])}";
-                            Console.WriteLine(line);
-                            sw.WriteLine(line);
+                                string line = $"{key}: {string.Join(", ", protections[key])}";
+                                Console.WriteLine(line);
+                                sw.WriteLine(line);
+                            }
                         }
                     }
+                    else
+                    {
+                        Console.WriteLine($"No protections found for {arg}");
+                    }
                 }
-                else
+                catch (Exception ex)
                 {
-                    Console.WriteLine($"No protections found for {arg}");
+                    using (StreamWriter sw = new StreamWriter(File.OpenWrite($"{DateTime.Now:yyyy-MM-dd_HHmmss}-exception.txt")))
+                    {
+                        sw.WriteLine(ex.Message);
+                    }
                 }
             }
 
@@ -51,7 +61,7 @@ namespace Test
             Console.ReadLine();
         }
 
-        private static void Changed(object source, FileProtection value)
+        private static void Changed(object source, ProtectionProgress value)
         {
             Console.WriteLine($"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}");
         }

Test/Test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net472;net48;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net472;net48;netcoreapp3.1;net5.0-windows</TargetFrameworks>
     <PlatformTarget>x86</PlatformTarget>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <OutputType>Exe</OutputType>