Fix linux publish script

.github/workflows/build_nupkg.yml

@@ -16,7 +16,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 8.0.x
+        dotnet-version: 9.0.x
         
     - name: Restore dependencies
       run: dotnet restore

.github/workflows/build_programs.yml

@@ -1,4 +1,4 @@
-name: Build Test
+name: Build Programs
 
 on:
   push:
@@ -10,10 +10,10 @@ jobs:
 
     strategy:
       matrix:
-        project: [Test]
+        project: [ExtractionTool, ProtectionScan]
         runtime: [win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64]
-        framework: [net8.0] #[net20, net35, net40, net452, net472, net48, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0]
-        conf: [Release, Debug]
+        framework: [net9.0] #[net20, net35, net40, net452, net472, net48, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0, net9.0]
+        conf: [Debug] #[Release, Debug]
 
     steps:
     - uses: actions/checkout@v4
@@ -23,16 +23,18 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 8.0.x
+        dotnet-version: 9.0.x
         
     - name: Restore dependencies
       run: dotnet restore
       
     - name: Build
-      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c ${{ matrix.conf == 'Release' && 'Release -p:DebugType=None -p:DebugSymbols=false' || 'Debug'}} --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
+      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c ${{ matrix.conf == 'Release' && 'Release -p:DebugType=None -p:DebugSymbols=false' || 'Debug'}} --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8') || startsWith(matrix.framework, 'net9')) && '-p:PublishSingleFile=true' || ''}}
         
     - name: Archive build
-      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_${{ matrix.conf }}.zip ${{ matrix.project }}/bin/${{ matrix.conf }}/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
+      run: |
+        cd ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
+        zip -r ${{ github.workspace }}/${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_${{ matrix.conf }}.zip ./
         
     - name: Upload build
       uses: actions/upload-artifact@v4

.github/workflows/check_pr.yml

@@ -11,7 +11,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 8.0.x
+        dotnet-version: 9.0.x
       
     - name: Build
       run: dotnet build

.vscode/launch.json

@@ -5,14 +5,27 @@
    "version": "0.2.0",
    "configurations": [
         {
-            "name": ".NET Core Launch (Test)",
+            "name": ".NET Core Launch (ProtectionScan)",
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/Test/bin/Debug/net8.0/Test.dll",
+            "program": "${workspaceFolder}/ProtectionScan/bin/Debug/net9.0/ProtectionScan.dll",
             "args": [],
-            "cwd": "${workspaceFolder}/Test",
+            "cwd": "${workspaceFolder}/ProtectionScan",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Launch (ExtractionTool)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/ExtractionTool/bin/Debug/net9.0/ExtractionTool.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/ExtractionTool",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",
             "stopAtEntry": false

BinaryObjectScanner.sln

@@ -3,8 +3,6 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.1.32407.343
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test", "Test\Test.csproj", "{88735BA2-778D-4192-8EB2-FFF6843719E2}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{68D10531-99CB-40B1-8912-73FA286C9433}"
 	ProjectSection(SolutionItems) = preProject
 		appveyor.yml = appveyor.yml
@@ -18,20 +16,28 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BinaryObjectScanner", "BinaryObjectScanner\BinaryObjectScanner.csproj", "{341EA3F5-847C-4739-B86F-2B051FFE4EF2}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtectionScan", "ProtectionScan\ProtectionScan.csproj", "{14CC56E0-7D56-497C-BF3D-4C06FA169831}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExtractionTool", "ExtractionTool\ExtractionTool.csproj", "{89767A19-043F-4251-805B-B2CBC48E2B79}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{88735BA2-778D-4192-8EB2-FFF6843719E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{88735BA2-778D-4192-8EB2-FFF6843719E2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{88735BA2-778D-4192-8EB2-FFF6843719E2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{88735BA2-778D-4192-8EB2-FFF6843719E2}.Release|Any CPU.Build.0 = Release|Any CPU
 		{341EA3F5-847C-4739-B86F-2B051FFE4EF2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{341EA3F5-847C-4739-B86F-2B051FFE4EF2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{341EA3F5-847C-4739-B86F-2B051FFE4EF2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{341EA3F5-847C-4739-B86F-2B051FFE4EF2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{14CC56E0-7D56-497C-BF3D-4C06FA169831}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{14CC56E0-7D56-497C-BF3D-4C06FA169831}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{14CC56E0-7D56-497C-BF3D-4C06FA169831}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{14CC56E0-7D56-497C-BF3D-4C06FA169831}.Release|Any CPU.Build.0 = Release|Any CPU
+		{89767A19-043F-4251-805B-B2CBC48E2B79}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{89767A19-043F-4251-805B-B2CBC48E2B79}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{89767A19-043F-4251-805B-B2CBC48E2B79}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{89767A19-043F-4251-805B-B2CBC48E2B79}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

BinaryObjectScanner/BinaryObjectScanner.csproj

@@ -1,103 +1,111 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <!-- Assembly Properties -->
-    <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
-    <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <CheckEolTargetFramework>false</CheckEolTargetFramework>
-    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
-    <LangVersion>latest</LangVersion>
-    <Nullable>enable</Nullable>
-    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>3.1.15</Version>
-    <!-- Mostly added due to external libraries -->
-    <WarningsNotAsErrors>CS0162;CS0612;CS8600;CS8601;CS8602;CS8603;CS8604;CS8605;CS8618;CS8625;CS8634;CS8765;IL3000;NU5100</WarningsNotAsErrors>
-  
-    <!-- Package Properties -->
-    <Authors>Matt Nadareski</Authors>
-    <Description>Protection scanning library</Description>
-    <Copyright>Copyright (c)2018-2024 Matt Nadareski</Copyright>
-    <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/SabreTools/BinaryObjectScanner</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PackageTags>protection copy-protection scanning packer</PackageTags>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-  </PropertyGroup>
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <Version>3.2.0</Version>
+        <!-- Mostly added due to external libraries -->
+        <WarningsNotAsErrors>CS0162;CS0612;CS8600;CS8601;CS8602;CS8603;CS8604;CS8605;CS8618;CS8625;CS8634;CS8765;IL3000;NU5100</WarningsNotAsErrors>
 
-  <!-- Set a build flag for Windows specifically -->
-  <PropertyGroup Condition="'$(RuntimeIdentifier)'=='win-x86'">
-    <DefineConstants>$(DefineConstants);WIN</DefineConstants>
-  </PropertyGroup>
+        <!-- Package Properties -->
+        <Authors>Matt Nadareski</Authors>
+        <Description>Protection scanning library</Description>
+        <Copyright>Copyright (c)2018-2024 Matt Nadareski</Copyright>
+        <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/SabreTools/BinaryObjectScanner</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <PackageTags>protection copy-protection scanning packer</PackageTags>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    </PropertyGroup>
 
-  <!-- Exclude certain parts of external modules for by default -->
-  <PropertyGroup>
-    <DefaultItemExcludes>
-      $(DefaultItemExcludes);
-      **\AssemblyInfo.cs;
-      _EXTERNAL\LessIO\src\LessIO.Tests\**;
-      _EXTERNAL\libmspack4n\lib\**;
-      _EXTERNAL\libmspack4n\libmspack4ntest\**;
-      _EXTERNAL\stormlibsharp\lib\**;
-      _EXTERNAL\stormlibsharp\src\TestConsole\**
-    </DefaultItemExcludes>
-  </PropertyGroup>
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+    </PropertyGroup>
 
-  <!-- Exclude all StormLibSharp for .NET Framework 4.0 -->
-  <PropertyGroup Condition="$(TargetFramework.StartsWith(`net40`))">
-    <DefaultItemExcludes>
-      $(DefaultItemExcludes);
-      _EXTERNAL\stormlibsharp\src\**
-    </DefaultItemExcludes>
-  </PropertyGroup>
+    <!-- Set a build flag for Windows specifically -->
+    <PropertyGroup Condition="'$(RuntimeIdentifier)'=='win-x86'">
+        <DefineConstants>$(DefineConstants);WIN</DefineConstants>
+    </PropertyGroup>
 
-  <!-- Exclude all external modules for .NET Framework 2.0, .NET Framework 3.5, or non-Windows builds -->
-  <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR !$(RuntimeIdentifier.StartsWith(`win-x86`))">
-    <DefaultItemExcludes>
-      $(DefaultItemExcludes);
-      _EXTERNAL\**
-    </DefaultItemExcludes>
-  </PropertyGroup>
+    <!-- Exclude certain parts of external modules for by default -->
+    <PropertyGroup>
+        <DefaultItemExcludes>
+            $(DefaultItemExcludes);
+            **\AssemblyInfo.cs;
+            _EXTERNAL\LessIO\src\LessIO.Tests\**;
+            _EXTERNAL\libmspack4n\lib\**;
+            _EXTERNAL\libmspack4n\libmspack4ntest\**;
+            _EXTERNAL\stormlibsharp\lib\**;
+            _EXTERNAL\stormlibsharp\src\TestConsole\**
+        </DefaultItemExcludes>
+    </PropertyGroup>
 
-  <!-- These are needed for dealing with native Windows DLLs -->
-  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND $(RuntimeIdentifier.StartsWith(`win-x86`))">
-    <Content Include="*.dll">
-      <Pack>true</Pack>
-      <PackagePath>contentFiles;content</PackagePath>
-      <IncludeInPackage>true</IncludeInPackage>
-      <CopyToOutput>true</CopyToOutput>
-      <BuildAction>Content</BuildAction>
-      <copyToOutput>true</copyToOutput>
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      <CopyToPublishDirectory>Always</CopyToPublishDirectory>
-    </Content>
-  </ItemGroup>
+    <!-- Exclude all StormLibSharp for .NET Framework 4.0 -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net40`))">
+        <DefaultItemExcludes>
+            $(DefaultItemExcludes);
+            _EXTERNAL\stormlibsharp\src\**
+        </DefaultItemExcludes>
+    </PropertyGroup>
 
-  <!-- Support for old .NET versions -->
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
-    <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
-  </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`))">
-    <PackageReference Include="OpenMcdf" Version="2.3.1" />
-  </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
-    <PackageReference Include="SharpCompress" Version="0.38.0" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="8.0.0" />
-  </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-    <PackageReference Include="System.Memory" Version="4.5.5" />
-  </ItemGroup>
+    <!-- Exclude all external modules for .NET Framework 2.0, .NET Framework 3.5, or non-Windows
+    builds -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR !$(RuntimeIdentifier.StartsWith(`win-x86`))">
+        <DefaultItemExcludes>
+            $(DefaultItemExcludes);
+            _EXTERNAL\**
+        </DefaultItemExcludes>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="SabreTools.Compression" Version="0.5.2" />
-    <PackageReference Include="SabreTools.Hashing" Version="1.2.2" />
-    <PackageReference Include="SabreTools.IO" Version="1.4.13" />
-    <PackageReference Include="SabreTools.Matching" Version="1.3.3" />
-    <PackageReference Include="SabreTools.Models" Version="1.4.11" />
-    <PackageReference Include="SabreTools.Serialization" Version="1.6.9" />
-    <PackageReference Include="UnshieldSharp" Version="1.8.5" />
-    <PackageReference Include="WiseUnpacker" Version="1.4.4" />
-  </ItemGroup>
+    <!-- These are needed for dealing with native Windows DLLs -->
+    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND $(RuntimeIdentifier.StartsWith(`win-x86`))">
+        <Content Include="*.dll">
+            <Pack>true</Pack>
+            <PackagePath>contentFiles;content</PackagePath>
+            <IncludeInPackage>true</IncludeInPackage>
+            <CopyToOutput>true</CopyToOutput>
+            <BuildAction>Content</BuildAction>
+            <copyToOutput>true</copyToOutput>
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+            <CopyToPublishDirectory>Always</CopyToPublishDirectory>
+        </Content>
+    </ItemGroup>
 
-</Project>
+    <!-- Support for old .NET versions -->
+    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`))">
+        <PackageReference Include="OpenMcdf" Version="2.3.1" />
+    </ItemGroup>
+    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
+        <PackageReference Include="SharpCompress" Version="0.38.0" />
+        <PackageReference Include="System.Text.Encoding.CodePages" Version="8.0.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.Compression" Version="0.6.0" />
+        <PackageReference Include="SabreTools.Hashing" Version="1.4.0" />
+        <PackageReference Include="SabreTools.IO" Version="1.5.0" />
+        <PackageReference Include="SabreTools.Matching" Version="1.4.0" />
+        <PackageReference Include="SabreTools.Models" Version="1.5.0" />
+        <PackageReference Include="SabreTools.Serialization" Version="1.7.0" />
+        <PackageReference Include="UnshieldSharp" Version="1.9.0" />
+        <PackageReference Include="WiseUnpacker" Version="1.5.0" />
+    </ItemGroup>
+
+</Project>

BinaryObjectScanner/Data/StaticChecks.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Serialization.Wrappers;
+
+namespace BinaryObjectScanner.Data
+{
+    internal static class StaticChecks
+    {
+        #region Public Collections
+
+        /// <summary>
+        /// Cache for all IContentCheck types
+        /// </summary>
+        public static List<IContentCheck> ContentCheckClasses
+        {
+            get
+            {
+                contentCheckClasses ??= InitCheckClasses<IContentCheck>();
+                return contentCheckClasses ?? [];
+            }
+        }
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<LinearExecutable> types
+        /// </summary>
+        public static List<IExecutableCheck<LinearExecutable>> LinearExecutableCheckClasses
+        {
+            get
+            {
+                linearExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<LinearExecutable>>();
+                return linearExecutableCheckClasses ?? [];
+            }
+        }
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<MSDOS> types
+        /// </summary>
+        public static List<IExecutableCheck<MSDOS>> MSDOSExecutableCheckClasses
+        {
+            get
+            {
+                msdosExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<MSDOS>>();
+                return msdosExecutableCheckClasses ?? [];
+            }
+        }
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<NewExecutable> types
+        /// </summary>
+        public static List<IExecutableCheck<NewExecutable>> NewExecutableCheckClasses
+        {
+            get
+            {
+                newExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<NewExecutable>>();
+                return newExecutableCheckClasses ?? [];
+            }
+        }
+
+        /// <summary>
+        /// Cache for all IPathCheck types
+        /// </summary>
+        public static List<IPathCheck> PathCheckClasses
+        {
+            get
+            {
+                pathCheckClasses ??= InitCheckClasses<IPathCheck>();
+                return pathCheckClasses ?? [];
+            }
+        }
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<PortableExecutable> types
+        /// </summary>
+        public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheckClasses
+        {
+            get
+            {
+                portableExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<PortableExecutable>>();
+                return portableExecutableCheckClasses ?? [];
+            }
+        }
+
+        #endregion
+
+        #region Internal Instances
+
+        /// <summary>
+        /// Cache for all IContentCheck types
+        /// </summary>
+        private static List<IContentCheck>? contentCheckClasses;
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<LinearExecutable> types
+        /// </summary>
+        private static List<IExecutableCheck<LinearExecutable>>? linearExecutableCheckClasses;
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<MSDOS> types
+        /// </summary>
+        private static List<IExecutableCheck<MSDOS>>? msdosExecutableCheckClasses;
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<NewExecutable> types
+        /// </summary>
+        private static List<IExecutableCheck<NewExecutable>>? newExecutableCheckClasses;
+
+        /// <summary>
+        /// Cache for all IPathCheck types
+        /// </summary>
+        private static List<IPathCheck>? pathCheckClasses;
+
+        /// <summary>
+        /// Cache for all IExecutableCheck<PortableExecutable> types
+        /// </summary>
+        private static List<IExecutableCheck<PortableExecutable>>? portableExecutableCheckClasses;
+
+        #endregion
+
+        /// <summary>
+        /// Initialize all implementations of a type
+        /// </summary>
+        private static List<T>? InitCheckClasses<T>() =>
+            InitCheckClasses<T>(Assembly.GetExecutingAssembly()) ?? [];
+
+        /// <summary>
+        /// Initialize all implementations of a type
+        /// </summary>
+        private static List<T>? InitCheckClasses<T>(Assembly assembly)
+        {
+            List<T> classTypes = [];
+
+            // If not all types can be loaded, use the ones that could be
+            Type?[] assemblyTypes = [];
+            try
+            {
+                assemblyTypes = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException rtle)
+            {
+                assemblyTypes = [.. rtle.Types];
+            }
+
+            // Get information from the type param
+            string interfaceName = typeof(T)!.FullName!;
+
+            // Loop through all types 
+            foreach (Type? type in assemblyTypes)
+            {
+                // Skip invalid types
+                if (type == null)
+                    continue;
+
+                // If the type isn't a class
+                if (!type.IsClass)
+                    continue;
+
+                // If the type isn't a class or doesn't implement the interface
+                bool interfaceFound = false;
+                foreach (var ii in type.GetInterfaces())
+                {
+                    if (ii.FullName != interfaceName)
+                        continue;
+
+                    interfaceFound = true;
+                    break;
+                }
+                if (!interfaceFound)
+                    continue;
+
+                // Try to create a concrete instance of the type
+                var instance = (T?)Activator.CreateInstance(type);
+                if (instance != null)
+                    classTypes.Add(instance);
+            }
+
+            return classTypes;
+        }    
+    }
+}

BinaryObjectScanner/FileType/AACSMediaKeyBlock.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 
 namespace BinaryObjectScanner.FileType
@@ -16,10 +15,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -34,7 +31,7 @@ namespace BinaryObjectScanner.FileType
                     return null;
 
                 // Derive the version, if possible
-                var typeAndVersion = mkb.Model.Records?.FirstOrDefault(r => r?.RecordType == SabreTools.Models.AACS.RecordType.TypeAndVersion);
+                var typeAndVersion = Array.Find(mkb.Model.Records ?? [], r => r?.RecordType == SabreTools.Models.AACS.RecordType.TypeAndVersion);
                 if (typeAndVersion == null)
                     return "AACS (Unknown Version)";
                 else

BinaryObjectScanner/FileType/BDPlusSVM.cs

@@ -15,10 +15,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>

BinaryObjectScanner/FileType/BFPK.cs

@@ -14,38 +14,35 @@ namespace BinaryObjectScanner.FileType
     public class BFPK : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var bfpk = SabreTools.Serialization.Wrappers.BFPK.Create(stream);
                 if (bfpk == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Extract all files
-                ExtractAll(bfpk, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(bfpk, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/BSP.cs

@@ -11,41 +11,36 @@ namespace BinaryObjectScanner.FileType
     public class BSP : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var bsp = SabreTools.Serialization.Wrappers.BSP.Create(stream);
                 if (bsp == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAllLumps(bsp, tempPath);
-                ExtractAllTextures(bsp, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAllLumps(bsp, outDir);
+                ExtractAllTextures(bsp, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/BZip2.cs

@@ -14,46 +14,44 @@ namespace BinaryObjectScanner.FileType
     public class BZip2 : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                // Try opening the stream
+                using var bz2File = new BZip2Stream(stream, CompressionMode.Decompress, true);
 
-                using (BZip2Stream bz2File = new BZip2Stream(stream, CompressionMode.Decompress, true))
-                {
-                    string tempFile = Path.Combine(tempPath, Guid.NewGuid().ToString());
-                    using (FileStream fs = File.OpenWrite(tempFile))
-                    {
-                        bz2File.CopyTo(fs);
-                    }
-                }
+                // Create the output file path
+                Directory.CreateDirectory(outDir);
+                string tempFile = Path.Combine(outDir, Guid.NewGuid().ToString());
 
-                return tempPath;
+                // Extract the file
+                using FileStream fs = File.OpenWrite(tempFile);
+                bz2File.CopyTo(fs);
+
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/CFB.cs

@@ -14,79 +14,75 @@ namespace BinaryObjectScanner.FileType
     public class CFB : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
 #if NET20 || NET35
             // Not supported for .NET Framework 2.0 or .NET Framework 3.5 due to library support
-            return null;
+            return false;
 #else
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (CompoundFile msi = new CompoundFile(stream, CFSUpdateMode.ReadOnly, CFSConfiguration.Default))
+                using var msi = new CompoundFile(stream, CFSUpdateMode.ReadOnly, CFSConfiguration.Default);
+                msi.RootStorage.VisitEntries((e) =>
                 {
-                    msi.RootStorage.VisitEntries((e) =>
+                    try
                     {
-                        try
+                        if (!e.IsStream)
+                            return;
+
+                        var str = msi.RootStorage.GetStream(e.Name);
+                        if (str == null)
+                            return;
+
+                        byte[] strData = str.GetData();
+                        if (strData == null)
+                            return;
+
+                        var decoded = DecodeStreamName(e.Name)?.TrimEnd('\0');
+                        if (decoded == null)
+                            return;
+
+                        byte[] nameBytes = Encoding.UTF8.GetBytes(e.Name);
+
+                        // UTF-8 encoding of 0x4840.
+                        if (nameBytes[0] == 0xe4 && nameBytes[1] == 0xa1 && nameBytes[2] == 0x80)
+                            decoded = decoded.Substring(3);
+
+                        foreach (char c in Path.GetInvalidFileNameChars())
                         {
-                            if (!e.IsStream)
-                                return;
-
-                            var str = msi.RootStorage.GetStream(e.Name);
-                            if (str == null)
-                                return;
-
-                            byte[] strData = str.GetData();
-                            if (strData == null)
-                                return;
-
-                            var decoded = DecodeStreamName(e.Name)?.TrimEnd('\0');
-                            if (decoded == null)
-                                return;
-
-                            byte[] nameBytes = Encoding.UTF8.GetBytes(e.Name);
-
-                            // UTF-8 encoding of 0x4840.
-                            if (nameBytes[0] == 0xe4 && nameBytes[1] == 0xa1 && nameBytes[2] == 0x80)
-                                decoded = decoded.Substring(3);
-
-                            foreach (char c in Path.GetInvalidFileNameChars())
-                            {
-                                decoded = decoded.Replace(c, '_');
-                            }
-
-                            string filename = Path.Combine(tempPath, decoded);
-                            using (Stream fs = File.OpenWrite(filename))
-                            {
-                                fs.Write(strData, 0, strData.Length);
-                            }
+                            decoded = decoded.Replace(c, '_');
                         }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-                    }, recursive: true);
-                }
 
-                return tempPath;
+                        string tempFile = Path.Combine(outDir, decoded);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        using Stream fs = File.OpenWrite(tempFile);
+                        fs.Write(strData, 0, strData.Length);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
+                    }
+                }, recursive: true);
+
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #endif
         }

BinaryObjectScanner/FileType/Executable.cs

@@ -2,9 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection;
+using BinaryObjectScanner.Data;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.IO.Extensions;
+using SabreTools.Serialization.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.FileType
@@ -12,10 +13,6 @@ namespace BinaryObjectScanner.FileType
     /// <summary>
     /// Executable or library
     /// </summary>
-    /// <remarks>
-    /// Due to the complexity of executables, all extraction handling
-    /// another class that is used by the scanner
-    /// </remarks>
     public class Executable : IDetectable
     {
         #region Properties
@@ -30,95 +27,6 @@ namespace BinaryObjectScanner.FileType
         /// </summary>
         public bool IncludePackers { get; set; }
 
-        /// <summary>
-        /// Cache for all IContentCheck types
-        /// </summary>
-        public static IEnumerable<IContentCheck> ContentCheckClasses
-        {
-            get
-            {
-                contentCheckClasses ??= InitCheckClasses<IContentCheck>();
-                return contentCheckClasses ?? [];
-            }
-        }
-
-        /// <summary>
-        /// Cache for all ILinearExecutableCheck types
-        /// </summary>
-        public static IEnumerable<ILinearExecutableCheck> LinearExecutableCheckClasses
-        {
-            get
-            {
-                linearExecutableCheckClasses ??= InitCheckClasses<ILinearExecutableCheck>();
-                return linearExecutableCheckClasses ?? [];
-            }
-        }
-
-        /// <summary>
-        /// Cache for all IMSDOSExecutableCheck types
-        /// </summary>
-        public static IEnumerable<IMSDOSExecutableCheck> MSDOSExecutableCheckClasses
-        {
-            get
-            {
-                msdosExecutableCheckClasses ??= InitCheckClasses<IMSDOSExecutableCheck>();
-                return msdosExecutableCheckClasses ?? [];
-            }
-        }
-
-        /// <summary>
-        /// Cache for all INewExecutableCheck types
-        /// </summary>
-        public static IEnumerable<INewExecutableCheck> NewExecutableCheckClasses
-        {
-            get
-            {
-                newExecutableCheckClasses ??= InitCheckClasses<INewExecutableCheck>();
-                return newExecutableCheckClasses ?? [];
-            }
-        }
-
-        /// <summary>
-        /// Cache for all IPortableExecutableCheck types
-        /// </summary>
-        public static IEnumerable<IPortableExecutableCheck> PortableExecutableCheckClasses
-        {
-            get
-            {
-                portableExecutableCheckClasses ??= InitCheckClasses<IPortableExecutableCheck>();
-                return portableExecutableCheckClasses ?? [];
-            }
-        }
-
-        #endregion
-
-        #region Internal Instances
-
-        /// <summary>
-        /// Cache for all IContentCheck types
-        /// </summary>
-        private static IEnumerable<IContentCheck>? contentCheckClasses;
-
-        /// <summary>
-        /// Cache for all ILinearExecutableCheck types
-        /// </summary>
-        private static IEnumerable<ILinearExecutableCheck>? linearExecutableCheckClasses;
-
-        /// <summary>
-        /// Cache for all IMSDOSExecutableCheck types
-        /// </summary>
-        private static IEnumerable<IMSDOSExecutableCheck>? msdosExecutableCheckClasses;
-
-        /// <summary>
-        /// Cache for all INewExecutableCheck types
-        /// </summary>
-        private static IEnumerable<INewExecutableCheck>? newExecutableCheckClasses;
-
-        /// <summary>
-        /// Cache for all IPortableExecutableCheck types
-        /// </summary>
-        private static IEnumerable<IPortableExecutableCheck>? portableExecutableCheckClasses;
-
         #endregion
 
         /// <inheritdoc/>
@@ -134,48 +42,97 @@ namespace BinaryObjectScanner.FileType
         /// <inheritdoc/>
         public string? Detect(Stream stream, string file, bool includeDebug)
         {
-            // Try to create a wrapper for the proper executable type
-            var wrapper = WrapperFactory.CreateExecutableWrapper(stream);
-            if (wrapper == null)
+            // Get all non-nested protections
+            var protections = DetectDict(stream, file, getProtections: null, includeDebug);
+            if (protections.Count == 0)
                 return null;
 
             // Create the internal list
-            var protections = new List<string>();
+            var protectionList = new List<string>();
+            foreach (string key in protections.Keys)
+            {
+                protectionList.AddRange(protections[key]);
+            }
+
+            return string.Join(";", [.. protectionList]);
+        }
+
+        /// <inheritdoc cref="IDetectable.Detect(Stream, string, bool)"/>
+        /// <remarks>
+        /// Ideally, we wouldn't need to circumvent the proper handling of file types just for Executable,
+        /// but due to the complexity of scanning, this is not currently possible.
+        /// </remarks>
+        public ProtectionDictionary DetectDict(Stream stream,
+            string file,
+            Func<string, ProtectionDictionary>? getProtections,
+            bool includeDebug)
+        {
+            // Create the output dictionary
+            var protections = new ProtectionDictionary();
+
+            // Try to create a wrapper for the proper executable type
+            IWrapper? wrapper;
+            try
+            {
+                wrapper = WrapperFactory.CreateExecutableWrapper(stream);
+                if (wrapper == null)
+                    return protections;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return protections;
+            }
 
             // Only use generic content checks if we're in debug mode
             if (includeDebug)
             {
                 var subProtections = RunContentChecks(file, stream, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values);
+                protections.Append(file, subProtections.Values);
             }
 
             if (wrapper is MSDOS mz)
             {
-                var subProtections = RunMSDOSExecutableChecks(file, stream, mz, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values);
+                // Standard checks
+                var subProtections = RunExecutableChecks(file, mz, StaticChecks.MSDOSExecutableCheckClasses, includeDebug);
+                protections.Append(file, subProtections.Values);
+
+                // Extractable checks
+                var extractedProtections = HandleExtractableProtections(file, mz, subProtections.Keys, getProtections, includeDebug);
+                protections.Append(extractedProtections);
             }
             else if (wrapper is LinearExecutable lex)
             {
-                var subProtections = RunLinearExecutableChecks(file, stream, lex, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values);
+                // Standard checks
+                var subProtections = RunExecutableChecks(file, lex, StaticChecks.LinearExecutableCheckClasses, includeDebug);
+                protections.Append(file, subProtections.Values);
+
+                // Extractable checks
+                var extractedProtections = HandleExtractableProtections(file, lex, subProtections.Keys, getProtections, includeDebug);
+                protections.Append(extractedProtections);
             }
             else if (wrapper is NewExecutable nex)
             {
-                var subProtections = RunNewExecutableChecks(file, stream, nex, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values);
+                // Standard checks
+                var subProtections = RunExecutableChecks(file, nex, StaticChecks.NewExecutableCheckClasses, includeDebug);
+                protections.Append(file, subProtections.Values);
+
+                // Extractable checks
+                var extractedProtections = HandleExtractableProtections(file, nex, subProtections.Keys, getProtections, includeDebug);
+                protections.Append(extractedProtections);
             }
             else if (wrapper is PortableExecutable pex)
             {
-                var subProtections = RunPortableExecutableChecks(file, stream, pex, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values);
+                // Standard checks
+                var subProtections = RunExecutableChecks(file, pex, StaticChecks.PortableExecutableCheckClasses, includeDebug);
+                protections.Append(file, subProtections.Values);
+
+                // Extractable checks
+                var extractedProtections = HandleExtractableProtections(file, pex, subProtections.Keys, getProtections, includeDebug);
+                protections.Append(extractedProtections);
             }
 
-            return string.Join(";", [.. protections]);
+            return protections;
         }
 
         #region Check Runners
@@ -186,14 +143,17 @@ namespace BinaryObjectScanner.FileType
         /// <param name="file">Name of the source file of the stream, for tracking</param>
         /// <param name="stream">Stream to scan the contents of</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public IDictionary<IContentCheck, string>? RunContentChecks(string? file, Stream stream, bool includeDebug)
+        /// <returns>Set of protections in file, empty on error</returns>
+        public IDictionary<IContentCheck, string> RunContentChecks(string? file, Stream stream, bool includeDebug)
         {
+            // Create the output dictionary
+            var protections = new CheckDictionary<IContentCheck>();
+
             // If we have an invalid file
             if (string.IsNullOrEmpty(file))
-                return null;
+                return protections;
             else if (!File.Exists(file))
-                return null;
+                return protections;
 
             // Read the file contents
             byte[] fileContent = [];
@@ -201,19 +161,16 @@ namespace BinaryObjectScanner.FileType
             {
                 fileContent = stream.ReadBytes((int)stream.Length);
                 if (fileContent == null)
-                    return null;
+                    return protections;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return protections;
             }
 
-            // Create the output dictionary
-            var protections = new CheckDictionary<IContentCheck>();
-
             // Iterate through all checks
-            ContentCheckClasses.IterateWithAction(checkClass =>
+            StaticChecks.ContentCheckClasses.IterateWithAction(checkClass =>
             {
                 // Get the protection for the class, if possible
                 var protection = checkClass.CheckContents(file!, fileContent, includeDebug);
@@ -235,22 +192,26 @@ namespace BinaryObjectScanner.FileType
         }
 
         /// <summary>
-        /// Handle a single file based on all linear executable check implementations
+        /// Handle a single file based on all executable check implementations
         /// </summary>
         /// <param name="file">Name of the source file of the executable, for tracking</param>
-        /// <param name="lex">Executable to scan</param>
+        /// <param name="exe">Executable to scan</param>
+        /// <param name="checks">Set of checks to use</param>
+        /// <param name="scanner">Scanner for handling recursive protections</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public IDictionary<ILinearExecutableCheck, string> RunLinearExecutableChecks(string file, Stream stream, LinearExecutable lex, bool includeDebug)
+        /// <returns>Set of protections in file, empty on error</returns>
+        public IDictionary<U, string> RunExecutableChecks<T, U>(string file, T exe, List<U> checks, bool includeDebug)
+            where T : WrapperBase
+            where U : IExecutableCheck<T>
         {
             // Create the output dictionary
-            var protections = new CheckDictionary<ILinearExecutableCheck>();
+            var protections = new CheckDictionary<U>();
 
             // Iterate through all checks
-            LinearExecutableCheckClasses.IterateWithAction(checkClass =>
+            checks.IterateWithAction(checkClass =>
             {
                 // Get the protection for the class, if possible
-                var protection = checkClass.CheckLinearExecutable(file, lex, includeDebug);
+                var protection = checkClass.CheckExecutable(file, exe, includeDebug);
                 if (string.IsNullOrEmpty(protection))
                     return;
 
@@ -269,149 +230,95 @@ namespace BinaryObjectScanner.FileType
         }
 
         /// <summary>
-        /// Handle a single file based on all MS-DOS executable check implementations
+        /// Handle extractable protections, such as executable packers
         /// </summary>
-        /// <param name="file">Name of the source file of the executable, for tracking</param>
-        /// <param name="mz">Executable to scan</param>
+        /// <param name="file">Name of the source file of the stream, for tracking</param>
+        /// <param name="exe">Executable to scan the contents of</param>
+        /// <param name="checks">Set of classes returned from Exectuable scans</param>
+        /// <param name="getProtections">Optional function for handling recursive protections</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public IDictionary<IMSDOSExecutableCheck, string> RunMSDOSExecutableChecks(string file, Stream stream, MSDOS mz, bool includeDebug)
+        /// <returns>Set of protections found from extraction, empty on error</returns>
+        private static ProtectionDictionary HandleExtractableProtections<T, U>(string file,
+            T exe,
+            IEnumerable<U> checks,
+            Func<string, ProtectionDictionary>? getProtections,
+            bool includeDebug)
+                where T : WrapperBase
+                where U : IExecutableCheck<T>
         {
             // Create the output dictionary
-            var protections = new CheckDictionary<IMSDOSExecutableCheck>();
+            var protections = new ProtectionDictionary();
 
-            // Iterate through all checks
-            MSDOSExecutableCheckClasses.IterateWithAction(checkClass =>
+            // If we have an invalid set of classes
+            if (checks == null)
+                return protections;
+
+            // If we have any extractable packers
+            var extractables = checks
+                .Where(c => c is IExtractableExecutable<T>)
+                .Select(c => c as IExtractableExecutable<T>);
+            extractables.IterateWithAction(extractable =>
             {
-                // Get the protection for the class, if possible
-                var protection = checkClass.CheckMSDOSExecutable(file, mz, includeDebug);
-                if (string.IsNullOrEmpty(protection))
-                    return;
-
-                // If we are filtering on game engines
-                if (CheckIfGameEngine(checkClass) && !IncludeGameEngines)
-                    return;
-
-                // If we are filtering on packers
-                if (CheckIfPacker(checkClass) && !IncludePackers)
-                    return;
-
-                protections.Append(checkClass, protection);
+                var subProtections = PerformExtractableCheck(extractable!, file, exe, getProtections, includeDebug);
+                protections.Append(subProtections);
             });
 
             return protections;
         }
 
         /// <summary>
-        /// Handle a single file based on all new executable check implementations
+        /// Handle files based on an IExtractableExecutable implementation
         /// </summary>
-        /// <param name="file">Name of the source file of the executable, for tracking</param>
-        /// <param name="nex">Executable to scan</param>
+        /// <param name="file">Name of the source file of the stream, for tracking</param>
+        /// <param name="exe">Executable to scan the contents of</param>
+        /// <param name="impl">IExtractableExecutable class representing the file type</param>
+        /// <param name="getProtections">Optional function for handling recursive protections</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public IDictionary<INewExecutableCheck, string> RunNewExecutableChecks(string file, Stream stream, NewExecutable nex, bool includeDebug)
+        /// <returns>Set of protections in path, empty on error</returns>
+        private static ProtectionDictionary PerformExtractableCheck<T>(IExtractableExecutable<T> impl,
+            string file,
+            T exe,
+            Func<string, ProtectionDictionary>? getProtections,
+            bool includeDebug)
+                where T : WrapperBase
         {
-            // Create the output dictionary
-            var protections = new CheckDictionary<INewExecutableCheck>();
+            // If we have an invalid extractable somehow
+            if (impl == null)
+                return [];
 
-            // Iterate through all checks
-            NewExecutableCheckClasses.IterateWithAction(checkClass =>
-            {
-                // Get the protection for the class, if possible
-                var protection = checkClass.CheckNewExecutable(file, nex, includeDebug);
-                if (string.IsNullOrEmpty(protection))
-                    return;
-
-                // If we are filtering on game engines
-                if (CheckIfGameEngine(checkClass) && !IncludeGameEngines)
-                    return;
-
-                // If we are filtering on packers
-                if (CheckIfPacker(checkClass) && !IncludePackers)
-                    return;
-
-                protections.Append(checkClass, protection);
-            });
-
-            return protections;
-        }
-
-        /// <summary>
-        /// Handle a single file based on all portable executable check implementations
-        /// </summary>
-        /// <param name="file">Name of the source file of the executable, for tracking</param>
-        /// <param name="pex">Executable to scan</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public IDictionary<IPortableExecutableCheck, string> RunPortableExecutableChecks(string file, Stream stream, PortableExecutable pex, bool includeDebug)
-        {
-            // Create the output dictionary
-            var protections = new CheckDictionary<IPortableExecutableCheck>();
-
-            // Iterate through all checks
-            PortableExecutableCheckClasses.IterateWithAction(checkClass =>
-            {
-                // Get the protection for the class, if possible
-                var protection = checkClass.CheckPortableExecutable(file, pex, includeDebug);
-                if (string.IsNullOrEmpty(protection))
-                    return;
-
-                // If we are filtering on game engines
-                if (CheckIfGameEngine(checkClass) && !IncludeGameEngines)
-                    return;
-
-                // If we are filtering on packers
-                if (CheckIfPacker(checkClass) && !IncludePackers)
-                    return;
-
-                protections.Append(checkClass, protection);
-            });
-
-            return protections;
-        }
-
-        #endregion
-
-        #region Initializers
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T>? InitCheckClasses<T>() =>
-            InitCheckClasses<T>(Assembly.GetExecutingAssembly()) ?? [];
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T>? InitCheckClasses<T>(Assembly assembly)
-        {
-            List<T> classTypes = [];
-
-            // If not all types can be loaded, use the ones that could be
-            List<Type> assemblyTypes = [];
+            // If the extractable file itself fails
             try
             {
-                assemblyTypes = assembly.GetTypes().ToList<Type>();
+                // Extract and get the output path
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                bool extracted = impl.Extract(file, exe, tempPath, includeDebug);
+
+                // Collect and format all found protections
+                ProtectionDictionary? subProtections = null;
+                if (extracted && getProtections != null)
+                    subProtections = getProtections(tempPath);
+
+                // If temp directory cleanup fails
+                try
+                {
+                    if (Directory.Exists(tempPath))
+                        Directory.Delete(tempPath, true);
+                }
+                catch (Exception ex)
+                {
+                    if (includeDebug) Console.WriteLine(ex);
+                }
+
+                // Prepare the returned protections
+                subProtections?.StripFromKeys(tempPath);
+                subProtections?.PrependToKeys(file);
+                return subProtections ?? [];
             }
-            catch (ReflectionTypeLoadException rtle)
+            catch (Exception ex)
             {
-                assemblyTypes = rtle.Types.Where(t => t != null)!.ToList<Type>();
+                if (includeDebug) Console.WriteLine(ex);
+                return [];
             }
-
-            // Loop through all types 
-            foreach (Type type in assemblyTypes)
-            {
-                // If the type isn't a class or doesn't implement the interface
-                if (!type.IsClass || type.GetInterface(typeof(T).Name) == null)
-                    continue;
-
-                // Try to create a concrete instance of the type
-                var instance = (T?)Activator.CreateInstance(type);
-                if (instance != null)
-                    classTypes.Add(instance);
-            }
-
-            return classTypes;
         }
 
         #endregion
@@ -424,7 +331,7 @@ namespace BinaryObjectScanner.FileType
         /// <param name="impl">Implementation that was last used to check</param>
         private static bool CheckIfGameEngine(object impl)
         {
-            return impl?.GetType()?.Namespace?.ToLowerInvariant()?.Contains("gameengine") ?? false;
+            return impl.GetType().Namespace?.ToLowerInvariant()?.Contains("gameengine") ?? false;
         }
 
         /// <summary>
@@ -433,7 +340,7 @@ namespace BinaryObjectScanner.FileType
         /// <param name="impl">Implementation that was last used to check</param>
         private static bool CheckIfPacker(object impl)
         {
-            return impl.GetType()?.Namespace?.ToLowerInvariant()?.Contains("packer") ?? false;
+            return impl.GetType().Namespace?.ToLowerInvariant()?.Contains("packer") ?? false;
         }
 
         #endregion

BinaryObjectScanner/FileType/GCF.cs

@@ -11,40 +11,35 @@ namespace BinaryObjectScanner.FileType
     public class GCF : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var gcf = SabreTools.Serialization.Wrappers.GCF.Create(stream);
                 if (gcf == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAll(gcf, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(gcf, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/GZIP.cs

@@ -14,61 +14,59 @@ namespace BinaryObjectScanner.FileType
     public class GZIP : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (GZipArchive zipFile = GZipArchive.Open(stream))
+                using var zipFile = GZipArchive.Open(stream);
+                foreach (var entry in zipFile.Entries)
                 {
-                    foreach (var entry in zipFile.Entries)
+                    try
                     {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, entry.Key);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        entry.WriteToFile(tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/InstallShieldArchiveV3.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
+using ISv3 = UnshieldSharp.Archive.InstallShieldArchiveV3;
 
 namespace BinaryObjectScanner.FileType
 {
@@ -10,30 +11,26 @@ namespace BinaryObjectScanner.FileType
     public class InstallShieldArchiveV3 : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                UnshieldSharp.Archive.InstallShieldArchiveV3 archive = new UnshieldSharp.Archive.InstallShieldArchiveV3(file);
+                var archive = new ISv3(file);
                 foreach (var cfile in archive.Files)
                 {
                     try
                     {
-                        string tempFile = Path.Combine(tempPath, cfile.Key);
+                        string tempFile = Path.Combine(outDir, cfile.Key);
                         var directoryName = Path.GetDirectoryName(tempFile);
                         if (directoryName != null && !Directory.Exists(directoryName))
                             Directory.CreateDirectory(directoryName);
@@ -53,12 +50,12 @@ namespace BinaryObjectScanner.FileType
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
     }

BinaryObjectScanner/FileType/InstallShieldCAB.cs

@@ -12,17 +12,17 @@ namespace BinaryObjectScanner.FileType
     public class InstallShieldCAB : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             // Get the name of the first cabinet file or header
             var directory = Path.GetDirectoryName(file);
@@ -50,17 +50,13 @@ namespace BinaryObjectScanner.FileType
 
             // If we have anything but the first file
             if (!shouldScanCabinet)
-                return null;
+                return false;
 
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
                 var cabfile = InstallShieldCabinet.Open(file);
                 if (cabfile?.HeaderList == null)
-                    return null;
+                    return false;
 
                 for (int i = 0; i < cabfile.HeaderList.FileCount; i++)
                 {
@@ -74,11 +70,11 @@ namespace BinaryObjectScanner.FileType
                         try
                         {
                             string? filename = cabfile.HeaderList.GetFileName(i);
-                            tempFile = Path.Combine(tempPath, filename ?? string.Empty);
+                            tempFile = Path.Combine(outDir, filename ?? string.Empty);
                         }
                         catch
                         {
-                            tempFile = Path.Combine(tempPath, $"BAD_FILENAME{i}");
+                            tempFile = Path.Combine(outDir, $"BAD_FILENAME{i}");
                         }
 
                         cabfile.FileSave(i, tempFile);
@@ -89,12 +85,12 @@ namespace BinaryObjectScanner.FileType
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
     }

BinaryObjectScanner/FileType/LDSCRYPT.cs

@@ -16,10 +16,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -28,10 +26,14 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 byte[] magic = new byte[16];
-                stream.Read(magic, 0, 16);
+                int read = stream.Read(magic, 0, 16);
 
+#if NET20
+                if (Extensions.StartsWith(magic, new byte?[] { 0x4C, 0x44, 0x53, 0x43, 0x52, 0x59, 0x50, 0x54 }))
+#else
                 if (magic.StartsWith(new byte?[] { 0x4C, 0x44, 0x53, 0x43, 0x52, 0x59, 0x50, 0x54 }))
-                    return "Link Data Security encrypted file";
+#endif
+                return "Link Data Security encrypted file";
             }
             catch (Exception ex)
             {

BinaryObjectScanner/FileType/MPQ.cs

@@ -12,71 +12,68 @@ namespace BinaryObjectScanner.FileType
     public class MPQ : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         // TODO: Add stream opening support
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
 #if NET20 || NET35 || NET40 || !WIN
             // Not supported for old .NET due to feature requirements
             // Not supported in non-Windows builds due to DLL requirements
-            return null;
+            return false;
 #else
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), System.Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                // Try to open the archive and listfile
+                var mpqArchive = new MpqArchive(file, FileAccess.Read);
+                string? listfile = null;
+                MpqFileStream listStream = mpqArchive.OpenFile("(listfile)");
 
-                using (var mpqArchive = new MpqArchive(file, FileAccess.Read))
+                // If we can't read the listfile, we just return
+                if (!listStream.CanRead)
+                    return false;
+
+                // Read the listfile in for processing
+                using (var sr = new StreamReader(listStream))
                 {
-                    // Try to open the listfile
-                    string? listfile = null;
-                    MpqFileStream listStream = mpqArchive.OpenFile("(listfile)");
+                    listfile = sr.ReadToEnd();
+                }
 
-                    // If we can't read the listfile, we just return
-                    if (!listStream.CanRead)
-                        return null;
+                // Split the listfile by newlines
+                string[] listfileLines = listfile.Replace("\r\n", "\n").Split('\n');
 
-                    // Read the listfile in for processing
-                    using (var sr = new StreamReader(listStream))
+                // Loop over each entry
+                foreach (string sub in listfileLines)
+                {
+                    try
                     {
-                        listfile = sr.ReadToEnd();
+                        string tempFile = Path.Combine(outDir, sub);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        mpqArchive.ExtractFile(sub, tempFile);
                     }
-
-                    // Split the listfile by newlines
-                    string[] listfileLines = listfile.Replace("\r\n", "\n").Split('\n');
-
-                    // Loop over each entry
-                    foreach (string sub in listfileLines)
+                    catch (System.Exception ex)
                     {
-                        try
-                        {
-                            string tempFile = Path.Combine(tempPath, sub);
-                            Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
-                            mpqArchive.ExtractFile(sub, tempFile);
-                        }
-                        catch (System.Exception ex)
-                        {
-                            if (includeDebug) System.Console.WriteLine(ex);
-                        }
+                        if (includeDebug) System.Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (System.Exception ex)
             {
                 if (includeDebug) System.Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #endif
         }

BinaryObjectScanner/FileType/MicrosoftCAB.cs

@@ -14,53 +14,50 @@ namespace BinaryObjectScanner.FileType
     public class MicrosoftCAB : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
 #if NET20 || NET35 || !WIN
             // Not supported for old .NET due to feature requirements
             // Not supported in non-Windows builds due to DLL requirements
-            return null;
+            return false;
 #else
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), System.Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (var cabArchive = new MSCabinet(file))
+                // Loop over each entry
+                var cabArchive = new MSCabinet(file);
+                foreach (var compressedFile in cabArchive.GetFiles())
                 {
-                    // Loop over each entry
-                    foreach (var compressedFile in cabArchive.GetFiles())
+                    try
                     {
-                        try
-                        {
-                            string tempFile = Path.Combine(tempPath, compressedFile.Filename);
-                            Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
-                            compressedFile.ExtractTo(tempFile);
-                        }
-                        catch (System.Exception ex)
-                        {
-                            if (includeDebug) System.Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, compressedFile.Filename);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        compressedFile.ExtractTo(tempFile);
+                    }
+                    catch (System.Exception ex)
+                    {
+                        if (includeDebug) System.Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (System.Exception ex)
             {
                 if (includeDebug) System.Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #endif
         }

BinaryObjectScanner/FileType/MicrosoftLZ.cs

@@ -12,29 +12,23 @@ namespace BinaryObjectScanner.FileType
     public class MicrosoftLZ : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
                 var data = Decompressor.Decompress(stream);
                 if (data == null)
-                    return null;
+                    return false;
 
                 // Create the temp filename
                 string tempFile = "temp.bin";
@@ -49,20 +43,20 @@ namespace BinaryObjectScanner.FileType
                         tempFile += "l";
                 }
 
-                tempFile = Path.Combine(tempPath, tempFile);
+                tempFile = Path.Combine(outDir, tempFile);
+                var directoryName = Path.GetDirectoryName(tempFile);
+                if (directoryName != null && !Directory.Exists(directoryName))
+                    Directory.CreateDirectory(directoryName);
 
-                // Write the file data to a temp file
-                using (Stream tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
-                {
-                    tempStream.Write(data, 0, data.Length);
-                }
+                using Stream tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
+                tempStream.Write(data, 0, data.Length);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
     }

BinaryObjectScanner/FileType/PAK.cs

@@ -10,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class PAK : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var pak = SabreTools.Serialization.Wrappers.PAK.Create(stream);
                 if (pak == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAll(pak, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(pak, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/PFF.cs

@@ -10,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class PFF : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var pff = SabreTools.Serialization.Wrappers.PFF.Create(stream);
                 if (pff == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Extract all files
-                ExtractAll(pff, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(pff, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex.Message);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/PKZIP.cs

@@ -4,6 +4,7 @@ using BinaryObjectScanner.Interfaces;
 #if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,68 +15,72 @@ namespace BinaryObjectScanner.FileType
     public class PKZIP : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
+            => Extract(file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(string, string, bool)"/>
+        public bool Extract(string file, string outDir, bool lookForHeader, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, lookForHeader, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
+            => Extract(stream, file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(Stream?, string, string, bool)"/>
+        public bool Extract(Stream? stream, string file, string outDir, bool lookForHeader, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (ZipArchive zipFile = ZipArchive.Open(stream))
+                var readerOptions = new ReaderOptions() { LookForHeader = lookForHeader };
+                using var zipFile = ZipArchive.Open(stream, readerOptions);
+                foreach (var entry in zipFile.Entries)
                 {
-                    foreach (var entry in zipFile.Entries)
+                    try
                     {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
 
-                            // If the entry is partial due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
+                        // If the entry is partial due to an incomplete multi-part archive, skip it
+                        if (!entry.IsComplete)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, entry.Key);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        entry.WriteToFile(tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/PLJ.cs

@@ -16,10 +16,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -28,9 +26,13 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 byte[] magic = new byte[16];
-                stream.Read(magic, 0, 16);
+                int read = stream.Read(magic, 0, 16);
 
+#if NET20
+                if (Extensions.StartsWith(magic, new byte?[] { 0xFF, 0x9D, 0x53, 0x4B }))
+#else
                 if (magic.StartsWith(new byte?[] { 0xFF, 0x9D, 0x53, 0x4B }))
+#endif
                     return "PlayJ Audio File";
             }
             catch (Exception ex)

BinaryObjectScanner/FileType/Quantum.cs

@@ -10,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class Quantum : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var quantum = SabreTools.Serialization.Wrappers.Quantum.Create(stream);
                 if (quantum == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Extract all files
-                ExtractAll(quantum, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(quantum, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex.Message);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/RAR.cs

@@ -4,6 +4,7 @@ using BinaryObjectScanner.Interfaces;
 #if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.Rar;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,68 +15,75 @@ namespace BinaryObjectScanner.FileType
     public class RAR : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
+            => Extract(file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(string, string, bool)"/>
+        public bool Extract(string file, string outDir, bool lookForHeader, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, lookForHeader, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
+            => Extract(stream, file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(Stream?, string, string, bool)"/>
+        public bool Extract(Stream? stream, string file, string outDir, bool lookForHeader, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                var readerOptions = new ReaderOptions() { LookForHeader = lookForHeader };
+                using RarArchive rarFile = RarArchive.Open(stream, readerOptions);
+                if (!rarFile.IsComplete)
+                    return false;
 
-                using (RarArchive rarFile = RarArchive.Open(stream))
+                foreach (var entry in rarFile.Entries)
                 {
-                    foreach (var entry in rarFile.Entries)
+                    try
                     {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
 
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
+                        // If we have a partial entry due to an incomplete multi-part archive, skip it
+                        if (!entry.IsComplete)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, entry.Key);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        entry.WriteToFile(tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/RealArcadeInstaller.cs

@@ -18,10 +18,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -30,11 +28,15 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 byte[] magic = new byte[16];
-                stream.Read(magic, 0, 16);
+                int read = stream.Read(magic, 0, 16);
 
                 // RASGI2.0
                 // Found in the ".rgs" files in IA item "Nova_RealArcadeCD_USA".
+#if NET20
+                if (Extensions.StartsWith(magic, new byte?[] { 0x52, 0x41, 0x53, 0x47, 0x49, 0x32, 0x2E, 0x30 }))
+#else
                 if (magic.StartsWith(new byte?[] { 0x52, 0x41, 0x53, 0x47, 0x49, 0x32, 0x2E, 0x30 }))
+#endif
                     return "RealArcade Installer";
             }
             catch (Exception ex)

BinaryObjectScanner/FileType/RealArcadeMezzanine.cs

@@ -18,10 +18,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -30,11 +28,15 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 byte[] magic = new byte[16];
-                stream.Read(magic, 0, 16);
+                int read = stream.Read(magic, 0, 16);
 
                 // XZip2.0
                 // Found in the ".mez" files in IA item "Nova_RealArcadeCD_USA".
+#if NET20
+                if (Extensions.StartsWith(magic, new byte?[] { 0x58, 0x5A, 0x69, 0x70, 0x32, 0x2E, 0x30 }))
+#else
                 if (magic.StartsWith(new byte?[] { 0x58, 0x5A, 0x69, 0x70, 0x32, 0x2E, 0x30 }))
+#endif
                     return "RealArcade Mezzanine";
             }
             catch (Exception ex)

BinaryObjectScanner/FileType/SFFS.cs

@@ -17,10 +17,8 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -29,10 +27,14 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 byte[] magic = new byte[16];
-                stream.Read(magic, 0, 16);
+                int read = stream.Read(magic, 0, 16);
 
+#if NET20
+                if (Extensions.StartsWith(magic, new byte?[] { 0x53, 0x46, 0x46, 0x53 }))
+#else
                 if (magic.StartsWith(new byte?[] { 0x53, 0x46, 0x46, 0x53 }))
-                    return "StarForce Filesystem Container";
+#endif
+                return "StarForce Filesystem Container";
             }
             catch (Exception ex)
             {
@@ -43,21 +45,19 @@ namespace BinaryObjectScanner.FileType
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/FileType/SGA.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Compression.zlib;
 
@@ -13,38 +12,35 @@ namespace BinaryObjectScanner.FileType
     public class SGA : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var sga = SabreTools.Serialization.Wrappers.SGA.Create(stream);
                 if (sga == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAll(sga, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(sga, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 
@@ -55,16 +51,15 @@ namespace BinaryObjectScanner.FileType
         /// <returns>True if all files extracted, false otherwise</returns>
         public static bool ExtractAll(SabreTools.Serialization.Wrappers.SGA item, string outputDirectory)
         {
-            // Get the number of files
-            int filesLength;
-            switch (item.Model.Header?.MajorVersion)
+            // Get the file count
+            int filesLength = item.Model.Directory switch
             {
-                case 4: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory4)?.Files?.Length ?? 0; break;
-                case 5: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory5)?.Files?.Length ?? 0; break;
-                case 6: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory6)?.Files?.Length ?? 0; break;
-                case 7: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory7)?.Files?.Length ?? 0; break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.Directory4 d4 => filesLength = d4.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory5 d5 => filesLength = d5.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory6 d6 => filesLength = d6.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory7 d7 => filesLength = d7.Files?.Length ?? 0,
+                _ => 0,
+            };
 
             // If we have no files
             if (filesLength == 0)
@@ -88,16 +83,15 @@ namespace BinaryObjectScanner.FileType
         /// <returns>True if the file extracted, false otherwise</returns>
         public static bool ExtractFile(SabreTools.Serialization.Wrappers.SGA item, int index, string outputDirectory)
         {
-            // Get the number of files
-            int filesLength;
-            switch (item.Model.Header?.MajorVersion)
+            // Get the file count
+            int filesLength = item.Model.Directory switch
             {
-                case 4: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory4)?.Files?.Length ?? 0; break;
-                case 5: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory5)?.Files?.Length ?? 0; break;
-                case 6: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory6)?.Files?.Length ?? 0; break;
-                case 7: filesLength = (item.Model.Directory as SabreTools.Models.SGA.Directory7)?.Files?.Length ?? 0; break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.Directory4 d4 => filesLength = d4.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory5 d5 => filesLength = d5.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory6 d6 => filesLength = d6.Files?.Length ?? 0,
+                SabreTools.Models.SGA.Directory7 d7 => filesLength = d7.Files?.Length ?? 0,
+                _ => 0,
+            };
 
             // If we have no files
             if (filesLength == 0)
@@ -108,55 +102,53 @@ namespace BinaryObjectScanner.FileType
                 return false;
 
             // Get the files
-            object? file;
-            switch (item.Model.Header?.MajorVersion)
+            object? file = item.Model.Directory switch
             {
-                case 4: file = (item.Model.Directory as SabreTools.Models.SGA.Directory4)?.Files?[index]; break;
-                case 5: file = (item.Model.Directory as SabreTools.Models.SGA.Directory5)?.Files?[index]; break;
-                case 6: file = (item.Model.Directory as SabreTools.Models.SGA.Directory6)?.Files?[index]; break;
-                case 7: file = (item.Model.Directory as SabreTools.Models.SGA.Directory7)?.Files?[index]; break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.Directory4 d4 => d4.Files![index],
+                SabreTools.Models.SGA.Directory5 d5 => d5.Files![index],
+                SabreTools.Models.SGA.Directory6 d6 => d6.Files![index],
+                SabreTools.Models.SGA.Directory7 d7 => d7.Files![index],
+                _ => null,
+            };
 
+            // If the file is invalid
             if (file == null)
                 return false;
 
             // Create the filename
-            var filename = string.Empty;
-            switch (item.Model.Header?.MajorVersion)
+            var filename = file switch
             {
-                case 4:
-                case 5: filename = (file as SabreTools.Models.SGA.File4)?.Name; break;
-                case 6: filename = (file as SabreTools.Models.SGA.File6)?.Name; break;
-                case 7: filename = (file as SabreTools.Models.SGA.File7)?.Name; break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.File4 f4 => f4.Name,
+                _ => null,
+            };
+
+            // If the filename is invalid
+            if (filename == null)
+                return false;
 
             // Loop through and get all parent directories
-            var parentNames = new List<string?> { filename };
+            var parentNames = new List<string> { filename };
 
             // Get the parent directory
-            var folder = default(object);
-            switch (item.Model.Header?.MajorVersion)
+            var folder = item.Model.Directory switch
             {
-                case 4: folder = (item.Model.Directory as SabreTools.Models.SGA.Directory4)?.Folders?.FirstOrDefault(f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex); break;
-                case 5: folder = (item.Model.Directory as SabreTools.Models.SGA.Directory5)?.Folders?.FirstOrDefault(f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex); break;
-                case 6: folder = (item.Model.Directory as SabreTools.Models.SGA.Directory6)?.Folders?.FirstOrDefault(f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex); break;
-                case 7: folder = (item.Model.Directory as SabreTools.Models.SGA.Directory7)?.Folders?.FirstOrDefault(f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex); break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.Directory4 d4 => Array.Find(d4.Folders ?? [], f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex),
+                SabreTools.Models.SGA.Directory5 d5 => Array.Find(d5.Folders ?? [], f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex),
+                SabreTools.Models.SGA.Directory6 d6 => Array.Find(d6.Folders ?? [], f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex),
+                SabreTools.Models.SGA.Directory7 d7 => Array.Find(d7.Folders ?? [], f => f != null && index >= f.FileStartIndex && index <= f.FileEndIndex),
+                _ => default(object),
+            };
 
             // If we have a parent folder
             if (folder != null)
             {
-                switch (item.Model.Header?.MajorVersion)
+                string folderName = folder switch
                 {
-                    case 4: parentNames.Add((folder as SabreTools.Models.SGA.Folder4)?.Name); break;
-                    case 5:
-                    case 6:
-                    case 7: parentNames.Add((folder as SabreTools.Models.SGA.Folder5)?.Name); break;
-                    default: return false;
-                }
+                    SabreTools.Models.SGA.Folder4 f4 => f4.Name ?? string.Empty,
+                    SabreTools.Models.SGA.Folder5 f5 => f5.Name ?? string.Empty,
+                    _ => string.Empty,
+                };
+                parentNames.Add(folderName);
             }
 
             // TODO: Should the section name/alias be used in the path as well?
@@ -164,55 +156,45 @@ namespace BinaryObjectScanner.FileType
             // Reverse and assemble the filename
             parentNames.Reverse();
 #if NET20 || NET35
-            var parentNamesArray = parentNames.Cast<string>().ToArray();
-            filename = parentNamesArray[0];
-            for (int i = 1; i < parentNamesArray.Length; i++)
+            filename = parentNames[0];
+            for (int i = 1; i < parentNames.Count; i++)
             {
-                filename = Path.Combine(filename, parentNamesArray[i]);
+                filename = Path.Combine(filename, parentNames[i]);
             }
 #else
-            filename = Path.Combine(parentNames.Cast<string>().ToArray());
+            filename = Path.Combine([.. parentNames]);
 #endif
 
             // Get the file offset
-            long fileOffset;
-            switch (item.Model.Header?.MajorVersion)
+            long fileOffset = file switch
             {
-                case 4:
-                case 5: fileOffset = (file as SabreTools.Models.SGA.File4)?.Offset ?? 0; break;
-                case 6: fileOffset = (file as SabreTools.Models.SGA.File6)?.Offset ?? 0; break;
-                case 7: fileOffset = (file as SabreTools.Models.SGA.File7)?.Offset ?? 0; break;
-                default: return false;
-            }
+                SabreTools.Models.SGA.File4 f4 => f4.Offset,
+                _ => -1,
+            };
 
             // Adjust the file offset
-            switch (item.Model.Header?.MajorVersion)
+            fileOffset += item.Model.Header switch
             {
-                case 4: fileOffset += (item.Model.Header as SabreTools.Models.SGA.Header4)?.FileDataOffset ?? 0; break;
-                case 5: fileOffset += (item.Model.Header as SabreTools.Models.SGA.Header4)?.FileDataOffset ?? 0; break;
-                case 6: fileOffset += (item.Model.Header as SabreTools.Models.SGA.Header6)?.FileDataOffset ?? 0; break;
-                case 7: fileOffset += (item.Model.Header as SabreTools.Models.SGA.Header6)?.FileDataOffset ?? 0; break;
-                default: return false;
+                SabreTools.Models.SGA.Header4 h4 => h4.FileDataOffset,
+                SabreTools.Models.SGA.Header6 h6 => h6.FileDataOffset,
+                _ => -1,
             };
 
+            // If the offset is invalid
+            if (fileOffset < 0)
+                return false;
+
             // Get the file sizes
             long fileSize, outputFileSize;
-            switch (item.Model.Header?.MajorVersion)
+            switch (file)
             {
-                case 4:
-                case 5:
-                    fileSize = (file as SabreTools.Models.SGA.File4)?.SizeOnDisk ?? 0;
-                    outputFileSize = (file as SabreTools.Models.SGA.File4)?.Size ?? 0;
+                case SabreTools.Models.SGA.File4 f4:
+                    fileSize = f4.SizeOnDisk;
+                    outputFileSize = f4.Size;
                     break;
-                case 6:
-                    fileSize = (file as SabreTools.Models.SGA.File6)?.SizeOnDisk ?? 0;
-                    outputFileSize = (file as SabreTools.Models.SGA.File6)?.Size ?? 0;
-                    break;
-                case 7:
-                    fileSize = (file as SabreTools.Models.SGA.File7)?.SizeOnDisk ?? 0;
-                    outputFileSize = (file as SabreTools.Models.SGA.File7)?.Size ?? 0;
-                    break;
-                default: return false;
+
+                default:
+                    return false;
             }
 
             // Read the compressed data directly

BinaryObjectScanner/FileType/SevenZip.cs

@@ -4,6 +4,7 @@ using BinaryObjectScanner.Interfaces;
 #if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.SevenZip;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,68 +15,72 @@ namespace BinaryObjectScanner.FileType
     public class SevenZip : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
+            => Extract(file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(string, string, bool)"/>
+        public bool Extract(string file, string outDir, bool lookForHeader, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, lookForHeader, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
+            => Extract(stream, file, outDir, lookForHeader: false, includeDebug);
+
+        /// <inheritdoc cref="IExtractable.Extract(Stream?, string, string, bool)"/>
+        public bool Extract(Stream? stream, string file, string outDir, bool lookForHeader, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (SevenZipArchive sevenZipFile = SevenZipArchive.Open(stream))
+                var readerOptions = new ReaderOptions() { LookForHeader = lookForHeader };
+                using var sevenZip = SevenZipArchive.Open(stream, readerOptions);
+                foreach (var entry in sevenZip.Entries)
                 {
-                    foreach (var entry in sevenZipFile.Entries)
+                    try
                     {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
 
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
+                        // If we have a partial entry due to an incomplete multi-part archive, skip it
+                        if (!entry.IsComplete)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, entry.Key);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        entry.WriteToFile(tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/TapeArchive.cs

@@ -14,69 +14,63 @@ namespace BinaryObjectScanner.FileType
     public class TapeArchive : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (TarArchive tarFile = TarArchive.Open(stream))
+                using var tarFile = TarArchive.Open(stream);
+                foreach (var entry in tarFile.Entries)
                 {
-                    foreach (var entry in tarFile.Entries)
+                    try
                     {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
 
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
+                        // If we have a partial entry due to an incomplete multi-part archive, skip it
+                        if (!entry.IsComplete)
+                            continue;
 
-                            // TODO: Fix bug with extracting folders from tar.
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        string tempFile = Path.Combine(outDir, entry.Key);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
+
+                        entry.WriteToFile(tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/VBSP.cs

@@ -10,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class VBSP : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var vbsp = SabreTools.Serialization.Wrappers.VBSP.Create(stream);
                 if (vbsp == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAllLumps(vbsp, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAllLumps(vbsp, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex.ToString());
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/VPK.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.IO.Extensions;
 
@@ -12,40 +11,35 @@ namespace BinaryObjectScanner.FileType
     public class VPK : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var vpk = SabreTools.Serialization.Wrappers.VPK.Create(stream);
                 if (vpk == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAll(vpk, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(vpk, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 
@@ -143,7 +137,7 @@ namespace BinaryObjectScanner.FileType
 
                 // If we have preload data, prepend it
                 if (data != null && directoryItem.PreloadData != null)
-                    data = directoryItem.PreloadData.Concat(data).ToArray();
+                    data = [.. directoryItem.PreloadData, .. data];
             }
 
             // If there is nothing to write out

BinaryObjectScanner/FileType/WAD.cs

@@ -10,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class WAD : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var wad = SabreTools.Serialization.Wrappers.WAD.Create(stream);
                 if (wad == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAllLumps(wad, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAllLumps(wad, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/FileType/XZ.cs

@@ -13,43 +13,41 @@ namespace BinaryObjectScanner.FileType
     public class XZ : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
             using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            return Extract(fs, file, includeDebug);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
 #if NET462_OR_GREATER || NETCOREAPP
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                // Try opening the stream
+                using var xzFile = new XZStream(stream);
 
-                using (XZStream xzFile = new XZStream(stream))
-                {
-                    string tempFile = Path.Combine(tempPath, Guid.NewGuid().ToString());
-                    using (FileStream fs = File.OpenWrite(tempFile))
-                    {
-                        xzFile.CopyTo(fs);
-                    }
-                }
+                // Create the output file path
+                Directory.CreateDirectory(outDir);
+                string tempFile = Path.Combine(outDir, Guid.NewGuid().ToString());
 
-                return tempPath;
+                // Extract the file
+                using FileStream fs = File.OpenWrite(tempFile);
+                xzFile.CopyTo(fs);
+
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
 #else
-            return null;
+            return false;
 #endif
         }
     }

BinaryObjectScanner/FileType/XZP.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 
 namespace BinaryObjectScanner.FileType
@@ -11,40 +10,35 @@ namespace BinaryObjectScanner.FileType
     public class XZP : IExtractable
     {
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, string outDir, bool includeDebug)
         {
             if (!File.Exists(file))
-                return null;
+                return false;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
         {
             try
             {
                 // Create the wrapper
                 var xzp = SabreTools.Serialization.Wrappers.XZP.Create(stream);
                 if (xzp == null)
-                    return null;
-
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Loop through and extract all files
-                ExtractAll(xzp, tempPath);
+                Directory.CreateDirectory(outDir);
+                ExtractAll(xzp, outDir);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 
@@ -95,7 +89,7 @@ namespace BinaryObjectScanner.FileType
                 return false;
 
             // Get the associated directory item
-            var directoryItem = item.Model.DirectoryItems.Where(di => di?.FileNameCRC == directoryEntry.FileNameCRC).FirstOrDefault();
+            var directoryItem = Array.Find(item.Model.DirectoryItems, di => di?.FileNameCRC == directoryEntry.FileNameCRC);
             if (directoryItem == null)
                 return false;
 

BinaryObjectScanner/GameEngine/RenderWare.cs

@@ -15,10 +15,10 @@ namespace BinaryObjectScanner.GameEngine
     /// RenderWare 3.7 SDK: https://github.com/sigmaco/rwsdk-v37-pc
     /// Wikipedia list of RenderWare games: https://en.wikipedia.org/wiki/Category:RenderWare_games
     /// </summary>
-    public class RenderWare : IPortableExecutableCheck
+    public class RenderWare : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Handler.cs

@@ -1,416 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using BinaryObjectScanner.Interfaces;
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner
-{
-    internal static class Handler
-    {
-        #region Public Collections
-
-        /// <summary>
-        /// Cache for all IPathCheck types
-        /// </summary>
-        public static IEnumerable<IPathCheck?> PathCheckClasses
-        {
-            get
-            {
-                pathCheckClasses ??= InitCheckClasses<IPathCheck>();
-                return pathCheckClasses;
-            }
-        }
-
-        #endregion
-
-        #region Internal Instances
-
-        /// <summary>
-        /// Cache for all IPathCheck types
-        /// </summary>
-        private static IEnumerable<IPathCheck?>? pathCheckClasses;
-
-        #endregion
-
-        #region Multiple Implementation Wrappers
-
-        /// <summary>
-        /// Handle a single path based on all path check implementations
-        /// </summary>
-        /// <param name="path">Path of the file or directory to check</param>
-        /// <param name="scanner">Scanner object to use for options and scanning</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary HandlePathChecks(string path, IEnumerable<string>? files)
-        {
-            // Create the output dictionary
-            var protections = new ProtectionDictionary();
-
-            // Preprocess the list of files
-            files = files?.Select(f => f.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar))?.ToList();
-
-            // Iterate through all checks
-            PathCheckClasses.IterateWithAction(checkClass =>
-            {
-                var subProtections = checkClass?.PerformCheck(path, files);
-                if (subProtections != null)
-                    protections.Append(path, subProtections);
-            });
-
-            return protections;
-        }
-
-        #endregion
-
-        #region Single Implementation Handlers
-
-        /// <summary>
-        /// Handle files based on an IDetectable implementation
-        /// </summary>
-        /// <param name="impl">IDetectable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="stream">Stream to scan the contents of</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static List<string>? HandleDetectable(IDetectable impl, string fileName, Stream stream, bool includeDebug)
-        {
-            var protection = impl.Detect(stream, fileName, includeDebug);
-            return ProcessProtectionString(protection);
-        }
-
-        /// <summary>
-        /// Handle files based on an IExtractable implementation
-        /// </summary>
-        /// <param name="impl">IExtractable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="stream">Stream to scan the contents of</param>
-        /// <param name="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary? HandleExtractable(IExtractable impl, string fileName, Stream? stream, Scanner scanner)
-        {
-            // If the extractable file itself fails
-            try
-            {
-                // Extract and get the output path
-                var tempPath = impl.Extract(stream, fileName, scanner.IncludeDebug);
-                if (tempPath == null)
-                    return null;
-
-                // Collect and format all found protections
-                var subProtections = scanner.GetProtections(tempPath);
-
-                // If temp directory cleanup fails
-                try
-                {
-                    Directory.Delete(tempPath, true);
-                }
-                catch (Exception ex)
-                {
-                    if (scanner.IncludeDebug) Console.WriteLine(ex);
-                }
-
-                // Prepare the returned protections
-                subProtections?.StripFromKeys(tempPath);
-                subProtections?.PrependToKeys(fileName);
-                return subProtections;
-            }
-            catch (Exception ex)
-            {
-                if (scanner.IncludeDebug) Console.WriteLine(ex);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Handle files based on an IExtractableMSDOSExecutable implementation
-        /// </summary>
-        /// <param name="impl">IExtractableMSDOSExecutable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="mz">MSDOS to scan the contents of</param>
-        /// <param name="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary? HandleExtractable(IExtractableMSDOSExecutable impl, string fileName, MSDOS mz, Scanner scanner)
-        {
-            // If the extractable file itself fails
-            try
-            {
-                // Extract and get the output path
-                var tempPath = impl.Extract(fileName, mz, scanner.IncludeDebug);
-                if (tempPath == null)
-                    return null;
-
-                // Collect and format all found protections
-                var subProtections = scanner.GetProtections(tempPath);
-
-                // If temp directory cleanup fails
-                try
-                {
-                    Directory.Delete(tempPath, true);
-                }
-                catch (Exception ex)
-                {
-                    if (scanner.IncludeDebug) Console.WriteLine(ex);
-                }
-
-                // Prepare the returned protections
-                subProtections?.StripFromKeys(tempPath);
-                subProtections?.PrependToKeys(fileName);
-                return subProtections;
-            }
-            catch (Exception ex)
-            {
-                if (scanner.IncludeDebug) Console.WriteLine(ex);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Handle files based on an IExtractableLinearExecutable implementation
-        /// </summary>
-        /// <param name="impl">IExtractableLinearExecutable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="lex">LinearExecutable to scan the contents of</param>
-        /// <param name="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary? HandleExtractable(IExtractableLinearExecutable impl, string fileName, LinearExecutable lex, Scanner scanner)
-        {
-            // If the extractable file itself fails
-            try
-            {
-                // Extract and get the output path
-                var tempPath = impl.Extract(fileName, lex, scanner.IncludeDebug);
-                if (tempPath == null)
-                    return null;
-
-                // Collect and format all found protections
-                var subProtections = scanner.GetProtections(tempPath);
-
-                // If temp directory cleanup fails
-                try
-                {
-                    Directory.Delete(tempPath, true);
-                }
-                catch (Exception ex)
-                {
-                    if (scanner.IncludeDebug) Console.WriteLine(ex);
-                }
-
-                // Prepare the returned protections
-                subProtections?.StripFromKeys(tempPath);
-                subProtections?.PrependToKeys(fileName);
-                return subProtections;
-            }
-            catch (Exception ex)
-            {
-                if (scanner.IncludeDebug) Console.WriteLine(ex);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Handle files based on an IExtractableNewExecutable implementation
-        /// </summary>
-        /// <param name="impl">IExtractableNewExecutable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="nex">NewExecutable to scan the contents of</param>
-        /// <param name="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary? HandleExtractable(IExtractableNewExecutable impl, string fileName, NewExecutable nex, Scanner scanner)
-        {
-            // If the extractable file itself fails
-            try
-            {
-                // Extract and get the output path
-                var tempPath = impl.Extract(fileName, nex, scanner.IncludeDebug);
-                if (tempPath == null)
-                    return null;
-
-                // Collect and format all found protections
-                var subProtections = scanner.GetProtections(tempPath);
-
-                // If temp directory cleanup fails
-                try
-                {
-                    Directory.Delete(tempPath, true);
-                }
-                catch (Exception ex)
-                {
-                    if (scanner.IncludeDebug) Console.WriteLine(ex);
-                }
-
-                // Prepare the returned protections
-                subProtections?.StripFromKeys(tempPath);
-                subProtections?.PrependToKeys(fileName);
-                return subProtections;
-            }
-            catch (Exception ex)
-            {
-                if (scanner.IncludeDebug) Console.WriteLine(ex);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Handle files based on an IExtractablePortableExecutable implementation
-        /// </summary>
-        /// <param name="impl">IExtractablePortableExecutable class representing the file type</param>
-        /// <param name="fileName">Name of the source file of the stream, for tracking</param>
-        /// <param name="pex">PortableExecutable to scan the contents of</param>
-        /// <param name="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ProtectionDictionary? HandleExtractable(IExtractablePortableExecutable impl, string fileName, PortableExecutable pex, Scanner scanner)
-        {
-            // If the extractable file itself fails
-            try
-            {
-                // Extract and get the output path
-                var tempPath = impl.Extract(fileName, pex, scanner.IncludeDebug);
-                if (tempPath == null)
-                    return null;
-
-                // Collect and format all found protections
-                var subProtections = scanner.GetProtections(tempPath);
-
-                // If temp directory cleanup fails
-                try
-                {
-                    Directory.Delete(tempPath, true);
-                }
-                catch (Exception ex)
-                {
-                    if (scanner.IncludeDebug) Console.WriteLine(ex);
-                }
-
-                // Prepare the returned protections
-                subProtections?.StripFromKeys(tempPath);
-                subProtections?.PrependToKeys(fileName);
-                return subProtections;
-            }
-            catch (Exception ex)
-            {
-                if (scanner.IncludeDebug) Console.WriteLine(ex);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Handle files based on an IPathCheck implementation
-        /// </summary>
-        /// <param name="impl">IPathCheck class representing the file type</param>
-        /// <param name="path">Path of the file or directory to check</param>
-        /// <returns>Set of protections in path, null on error</returns>
-        private static List<string>? PerformCheck(this IPathCheck impl, string? path, IEnumerable<string>? files)
-        {
-            // If we have an invalid path
-            if (string.IsNullOrEmpty(path))
-                return null;
-
-            // Setup the list
-            var protections = new List<string>();
-
-            // If we have a file path
-            if (File.Exists(path))
-            {
-                var protection = impl.CheckFilePath(path!);
-                var subProtections = ProcessProtectionString(protection);
-                if (subProtections != null)
-                    protections.AddRange(subProtections);
-            }
-
-            // If we have a directory path
-            if (Directory.Exists(path) && files?.Any() == true)
-            {
-                var subProtections = impl.CheckDirectoryPath(path!, files);
-                if (subProtections != null)
-                    protections.AddRange(subProtections);
-            }
-
-            return protections;
-        }
-
-        #endregion
-
-        #region Initializers
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T?> InitCheckClasses<T>() =>
-            InitCheckClasses<T>(Assembly.GetExecutingAssembly());
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T?> InitCheckClasses<T>(Assembly assembly)
-        {
-            List<T?> classTypes = [];
-
-            // If not all types can be loaded, use the ones that could be
-            List<Type> assemblyTypes = [];
-            try
-            {
-                assemblyTypes = assembly.GetTypes().ToList<Type>();
-            }
-            catch (ReflectionTypeLoadException rtle)
-            {
-                assemblyTypes = rtle.Types.Where(t => t != null)!.ToList<Type>();
-            }
-
-            // Loop through all types 
-            foreach (Type type in assemblyTypes)
-            {
-                // If the type isn't a class or doesn't implement the interface
-                if (!type.IsClass || type.GetInterface(typeof(T).Name) == null)
-                    continue;
-
-                // Try to create a concrete instance of the type
-                var instance = (T?)Activator.CreateInstance(type);
-                if (instance != null)
-                    classTypes.Add(instance);
-            }
-
-            return classTypes;
-        }
-
-        #endregion
-
-        #region Helpers
-
-        /// <summary>
-        /// Process a protection string if it includes multiple protections
-        /// </summary>
-        /// <param name="protection">Protection string to process</param>
-        /// <returns>Set of protections parsed, null on error</returns>
-        private static List<string>? ProcessProtectionString(string? protection)
-        {
-            // If we have an invalid protection string
-            if (string.IsNullOrEmpty(protection))
-                return null;
-
-            // Setup the output queue
-            var protections = new List<string>();
-
-            // If we have an indicator of multiple protections
-            if (protection!.Contains(";"))
-            {
-                var splitProtections = protection.Split(';');
-                protections.AddRange(splitProtections);
-            }
-            else
-            {
-                protections.Add(protection);
-            }
-
-            return protections;
-        }
-
-        #endregion
-    }
-}

BinaryObjectScanner/Interfaces/IExecutableCheck.cs

@@ -1,19 +1,19 @@
-using SabreTools.Serialization.Wrappers;
+using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Interfaces
 {
     /// <summary>
-    /// Check a MS-DOS Executable (MZ) for protection
+    /// Check an executable for protection
     /// </summary>
-    public interface IMSDOSExecutableCheck
+    public interface IExecutableCheck<T> where T : WrapperBase
     {
         /// <summary>
         /// Check a path for protections based on file contents
         /// </summary>
         /// <param name="file">File to check for protection indicators</param>
-        /// <param name="mz">MSDOS representing the read-in file</param>
+        /// <param name="exe">Executable representing the read-in file</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
         /// <returns>String containing any protections found in the file</returns>
-        string? CheckMSDOSExecutable(string file, MSDOS mz, bool includeDebug);
+        string? CheckExecutable(string file, T exe, bool includeDebug);
     }
 }

BinaryObjectScanner/Interfaces/IExtractable.cs

@@ -5,26 +5,26 @@ namespace BinaryObjectScanner.Interfaces
     /// <summary>
     /// Mark a file type as being able to be extracted
     /// </summary>
-    /// TODO: Change to have output directory passed in
-    /// TODO: Change to return a bool
     public interface IExtractable
     {
         /// <summary>
         /// Extract a file to a temporary path, if possible
         /// </summary>
         /// <param name="file">Path to the input file</param>
+        /// <param name="outDir">Path to the output directory</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
+        /// <returns>Indicates if the extractable was successfully extracted</returns>
         /// <remarks>Ideally, this should just point to the other extract implementation.</remarks>
-        string? Extract(string file, bool includeDebug);
+        bool Extract(string file, string outDir, bool includeDebug);
 
         /// <summary>
         /// Extract a stream to a temporary path, if possible
         /// </summary>
         /// <param name="stream">Stream representing the input file</param>
         /// <param name="file">Path to the input file</param>
+        /// <param name="outDir">Path to the output directory</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
-        string? Extract(Stream? stream, string file, bool includeDebug);
+        /// <returns>Indicates if the extractable was successfully extracted</returns>
+        bool Extract(Stream? stream, string file, string outDir, bool includeDebug);
     }
 }

BinaryObjectScanner/Interfaces/IExtractableExecutable.cs

@@ -0,0 +1,20 @@
+using SabreTools.Serialization.Wrappers;
+
+namespace BinaryObjectScanner.Interfaces
+{
+    /// <summary>
+    /// Mark an executable type as being able to be extracted
+    /// </summary>
+    public interface IExtractableExecutable<T> : IExecutableCheck<T> where T : WrapperBase
+    {
+        /// <summary>
+        /// Extract an Executable to a path, if possible
+        /// </summary>
+        /// <param name="file">Path to the input file</param>
+        /// <param name="exe">Executable representing the read-in file</param>
+        /// <param name="outDir">Path to the output directory</param>
+        /// <param name="includeDebug">True to include debug data, false otherwise</param>
+        /// <returns>Path to extracted files, null on error</returns>
+        bool Extract(string file, T exe, string outDir, bool includeDebug);
+    }
+}

BinaryObjectScanner/Interfaces/IExtractableLinearExecutable.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Mark a LinearExecutable type as being able to be extracted
-    /// </summary>
-    public interface IExtractableLinearExecutable
-    {
-        /// <summary>
-        /// Extract a LinearExecutable to a temporary path, if possible
-        /// </summary>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="lex">LinearExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
-        string? Extract(string file, LinearExecutable lex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/IExtractableMSDOSExecutable.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Mark a MSDOS type as being able to be extracted
-    /// </summary>
-    public interface IExtractableMSDOSExecutable
-    {
-        /// <summary>
-        /// Extract a MSDOS to a temporary path, if possible
-        /// </summary>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="mz">MSDOS representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
-        string? Extract(string file, MSDOS mz, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/IExtractableNewExecutable.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Mark a NewExecutable type as being able to be extracted
-    /// </summary>
-    public interface IExtractableNewExecutable
-    {
-        /// <summary>
-        /// Extract a NewExecutable to a temporary path, if possible
-        /// </summary>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="nex">NewExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
-        string? Extract(string file, NewExecutable nex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/IExtractablePortableExecutable.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Mark a PortableExecutable type as being able to be extracted
-    /// </summary>
-    public interface IExtractablePortableExecutable
-    {
-        /// <summary>
-        /// Extract a PortableExecutable to a temporary path, if possible
-        /// </summary>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="pex">PortableExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>Path to extracted files, null on error</returns>
-        string? Extract(string file, PortableExecutable pex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/ILinearExecutableCheck.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Check a Linear Executable (LE) for protection
-    /// </summary>
-    public interface ILinearExecutableCheck
-    {
-        /// <summary>
-        /// Check a path for protections based on file contents
-        /// </summary>
-        /// <param name="file">File to check for protection indicators</param>
-        /// <param name="lex">LinearExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>String containing any protections found in the file</returns>
-        string? CheckLinearExecutable(string file, LinearExecutable lex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/INewExecutableCheck.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Check a New Executable (NE) for protection
-    /// </summary>
-    public interface INewExecutableCheck
-    {
-        /// <summary>
-        /// Check a path for protections based on file contents
-        /// </summary>
-        /// <param name="file">File to check for protection indicators</param>
-        /// <param name="nex">NewExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>String containing any protections found in the file</returns>
-        string? CheckNewExecutable(string file, NewExecutable nex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Interfaces/IPortableExecutableCheck.cs

@@ -1,19 +0,0 @@
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Interfaces
-{
-    /// <summary>
-    /// Check a Portable Executable (PE) for protection
-    /// </summary>
-    public interface IPortableExecutableCheck
-    {
-        /// <summary>
-        /// Check a path for protections based on file contents
-        /// </summary>
-        /// <param name="file">File to check for protection indicators</param>
-        /// <param name="pex">PortableExecutable representing the read-in file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>String containing any protections found in the file</returns>
-        string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug);
-    }
-}

BinaryObjectScanner/Packer/ASPack.cs

@@ -8,10 +8,10 @@ using SabreTools.Serialization.Wrappers;
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
-    public class ASPack : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class ASPack : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -51,9 +51,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         /// <summary>

BinaryObjectScanner/Packer/AdvancedInstaller.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -6,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // TODO: Verify that all versions are detected
-    public class AdvancedInstaller : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class AdvancedInstaller : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -20,7 +19,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".rdata");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("Software\\Caphyon\\Advanced Installer")))
+                if (strs.Exists(s => s.Contains("Software\\Caphyon\\Advanced Installer")))
                     return "Caphyon Advanced Installer";
             }
 
@@ -28,9 +27,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/AutoPlayMediaStudio.cs

@@ -7,10 +7,10 @@ namespace BinaryObjectScanner.Packer
     // Created by IndigoRose (creators of Setup Factory), primarily to be used to create autorun menus for various media.
     // Official website: https://www.autoplay.org/
     // TODO: Add extraction
-    public class AutoPlayMediaStudio : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class AutoPlayMediaStudio : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -33,9 +33,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/CExe.cs

@@ -13,10 +13,10 @@ namespace BinaryObjectScanner.Packer
     // The official website for CExe also includes the source code (which does have to be retrieved by the Wayback Machine)
     // http://www.scottlu.com/Content/CExe.html
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class CExe : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class CExe : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -51,14 +51,14 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             try
             {
                 // Get the first resource of type 99 with index 2
                 var payload = pex.FindResourceByNamedType("99, 2").FirstOrDefault();
                 if (payload == null || payload.Length == 0)
-                    return null;
+                    return false;
 
                 // Determine which compression was used
                 bool zlib = pex.FindResourceByNamedType("99, 1").Any();
@@ -94,12 +94,12 @@ namespace BinaryObjectScanner.Packer
 
                         // Trim the buffer to the proper size
                         uint read = zstream.total_out;
-#if NET462_OR_GREATER || NETCOREAPP
-                        data = new ReadOnlySpan<byte>(data, 0, (int)read).ToArray();
-#else
+#if NETFRAMEWORK
                         var temp = new byte[read];
                         Array.Copy(data, 0, temp, 0, read);
                         data = temp;
+#else
+                        data = new ReadOnlySpan<byte>(data, 0, (int)read).ToArray();
 #endif
                     }
                     catch
@@ -125,27 +125,25 @@ namespace BinaryObjectScanner.Packer
 
                 // If we have no data
                 if (data == null)
-                    return null;
-
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                    return false;
 
                 // Create the temp filename
                 string tempFile = string.IsNullOrEmpty(file) ? "temp.sxe" : $"{Path.GetFileNameWithoutExtension(file)}.sxe";
-                tempFile = Path.Combine(tempPath, tempFile);
+                tempFile = Path.Combine(outDir, tempFile);
+                var directoryName = Path.GetDirectoryName(tempFile);
+                if (directoryName != null && !Directory.Exists(directoryName))
+                    Directory.CreateDirectory(directoryName);
 
                 // Write the file data to a temp file
-                using (Stream tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
-                {
-                    tempStream.Write(data, 0, data.Length);
-                }
+                var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
+                tempStream.Write(data, 0, data.Length);
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
     }

BinaryObjectScanner/Packer/DotFuscator.cs

@@ -1,14 +1,13 @@
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
-    public class DotFuscator : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class DotFuscator : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -19,7 +18,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".text");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("DotfuscatorAttribute")))
+                if (strs.Exists(s => s.Contains("DotfuscatorAttribute")))
                     return "dotFuscator";
             }
 
@@ -27,9 +26,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/DotNetReactor.cs

@@ -15,10 +15,10 @@ namespace BinaryObjectScanner.Packer
     /// 
     /// Resource that could be useful for extraction: https://github.com/SychicBoy/NETReactorSlayer
     /// </summary>
-    public class DotNetReactor : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class DotNetReactor : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // TODO: Detect version
             // TODO: Further refine checks using https://github.com/horsicq/Detect-It-Easy/blob/075a70b1484d1d84d1dc37c86aac16188d5a84e7/db/PE/NetReactor.2.sg and https://github.com/cod3nym/detection-rules/blob/main/yara/dotnet/obf_net_reactor.yar
@@ -97,10 +97,10 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             // TODO: Add extraction
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/EXEStealth.cs

@@ -10,7 +10,7 @@ namespace BinaryObjectScanner.Packer
     // TODO: Detect 3.15 and up (maybe looking for `Metamorphism`)
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class EXEStealth : IContentCheck, IExtractablePortableExecutable, IPortableExecutableCheck
+    public class EXEStealth : IContentCheck, IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
         public string? CheckContents(string file, byte[] fileContent, bool includeDebug)
@@ -38,7 +38,7 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -75,9 +75,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/EmbeddedExecutable.cs

@@ -11,10 +11,10 @@ namespace BinaryObjectScanner.Packer
     /// Though not technically a packer, this detection is for any executables that include
     /// others in their resources in some uncompressed manner to be used at runtime.
     /// </summary>
-    public class EmbeddedExecutable : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class EmbeddedExecutable : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -22,31 +22,39 @@ namespace BinaryObjectScanner.Packer
                 return null;
 
             // Get the resources that have an executable signature
-            if (pex.ResourceData?.Any(kvp => kvp.Value is byte[] ba && ba.StartsWith(SabreTools.Models.MSDOS.Constants.SignatureBytes)) == true)
+            if (pex.ResourceData?.Any(kvp => kvp.Value is byte[] ba
+#if NET20
+                && Extensions.StartsWith(ba, SabreTools.Models.MSDOS.Constants.SignatureBytes)) == true)
+#else
+                && ba.StartsWith(SabreTools.Models.MSDOS.Constants.SignatureBytes)) == true)
+#endif
+            {
                 return "Embedded Executable";
+            }
 
             return null;
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             try
             {
                 // If there are no resources
                 if (pex.ResourceData == null)
-                    return null;
+                    return false;
 
                 // Get the resources that have an executable signature
                 var resources = pex.ResourceData
                     .Where(kvp => kvp.Value != null && kvp.Value is byte[])
                     .Select(kvp => kvp.Value as byte[])
+#if NET20
+                    .Where(b => b != null && Extensions.StartsWith(b, SabreTools.Models.MSDOS.Constants.SignatureBytes))
+#else
                     .Where(b => b != null && b.StartsWith(SabreTools.Models.MSDOS.Constants.SignatureBytes))
+#endif
                     .ToList();
 
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
                 for (int i = 0; i < resources.Count; i++)
                 {
                     try
@@ -58,7 +66,10 @@ namespace BinaryObjectScanner.Packer
 
                         // Create the temp filename
                         string tempFile = $"embedded_resource_{i}.bin";
-                        tempFile = Path.Combine(tempPath, tempFile);
+                        tempFile = Path.Combine(outDir, tempFile);
+                        var directoryName = Path.GetDirectoryName(tempFile);
+                        if (directoryName != null && !Directory.Exists(directoryName))
+                            Directory.CreateDirectory(directoryName);
 
                         // Write the resource data to a temp file
                         using var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
@@ -70,12 +81,12 @@ namespace BinaryObjectScanner.Packer
                     }
                 }
 
-                return tempPath;
+                return true;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
     }

BinaryObjectScanner/Packer/GenteeInstaller.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -6,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class GenteeInstaller : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class GenteeInstaller : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -20,10 +19,10 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("Gentee installer")))
+                if (strs.Exists(s => s.Contains("Gentee installer")))
                     return "Gentee Installer";
 
-                if (strs.Any(s => s.Contains("ginstall.dll")))
+                if (strs.Exists(s => s.Contains("ginstall.dll")))
                     return "Gentee Installer";
             }
 
@@ -31,9 +30,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/HyperTechCrackProof.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using System;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -9,10 +9,10 @@ namespace BinaryObjectScanner.Packer
     // https://www.reddit.com/r/riseofincarnates/comments/m3vbnm/subreddit_revival_does_anyone_still_have_rise_of/
     // https://steamcommunity.com/app/310950/discussions/0/4224890554455490819/
     // https://github.com/horsicq/Detect-It-Easy/blob/63a1aa8bb23ca02d8a7fd5936db8dbc5c5d52dea/db/PE/HyperTech%20Crackproof.2.sg
-    public class HyperTechCrackProof : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class HyperTechCrackProof : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -22,7 +22,8 @@ namespace BinaryObjectScanner.Packer
             // This check may be overly limiting, as it excludes the sample provided to DiE (https://github.com/horsicq/Detect-It-Easy/issues/102).
             // TODO: Find further samples and invesitgate if the "peC" section is only present on specific versions.
             bool peCSection = pex.ContainsSection("peC", exact: true);
-            bool importTableMatch = (pex.Model.ImportTable?.ImportDirectoryTable?.Any(idte => idte?.Name == "KeRnEl32.dLl") ?? false);
+            bool importTableMatch = Array.Exists(pex.Model.ImportTable?.ImportDirectoryTable ?? [],
+                idte => idte?.Name == "KeRnEl32.dLl");
 
             if (peCSection && importTableMatch)
                 return "HyperTech CrackProof";
@@ -31,9 +32,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/InnoSetup.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
 using SabreTools.Matching.Content;
@@ -9,10 +8,11 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction - https://github.com/dscharrer/InnoExtract
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class InnoSetup : IExtractablePortableExecutable, INewExecutableCheck, IPortableExecutableCheck
+    public class InnoSetup : IExecutableCheck<NewExecutable>,
+        IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckNewExecutable(string file, NewExecutable nex, bool includeDebug)
+        public string? CheckExecutable(string file, NewExecutable nex, bool includeDebug)
         {
             // Check for "Inno" in the reserved words
             if (nex.Model.Stub?.Header?.Reserved2?[4] == 0x6E49 && nex.Model.Stub?.Header?.Reserved2?[5] == 0x6F6E)
@@ -28,7 +28,7 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -39,7 +39,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                var str = strs.FirstOrDefault(s => s.StartsWith("Inno Setup Setup Data"));
+                var str = strs.Find(s => s.StartsWith("Inno Setup Setup Data"));
                 if (str != null)
                 {
                     return str.Replace("Inno Setup Setup Data", "Inno Setup")
@@ -54,9 +54,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         private static string GetOldVersion(string file, NewExecutable nex)

BinaryObjectScanner/Packer/InstallAnywhere.cs

@@ -6,10 +6,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction, which may be possible with the current libraries but needs to be investigated further.
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class InstallAnywhere : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class InstallAnywhere : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -28,9 +28,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/InstallerVISE.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -6,11 +5,11 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction - https://github.com/Bioruebe/UniExtract2
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class InstallerVISE : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class InstallerVISE : IExtractableExecutable<PortableExecutable>
     {
         //TODO: Add exact version detection for Windows builds, make sure versions before 3.X are detected as well, and detect the Mac builds.
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -21,7 +20,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("ViseMain")))
+                if (strs.Exists(s => s.Contains("ViseMain")))
                     return "Installer VISE";
             }
             
@@ -29,9 +28,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/IntelInstallationFramework.cs

@@ -5,10 +5,10 @@ using SabreTools.Serialization.Wrappers;
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction, seems to primarily use MSZip compression.
-    public class IntelInstallationFramework : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class IntelInstallationFramework : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -33,9 +33,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/MicrosoftCABSFX.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -7,10 +6,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction, which should be possible with LibMSPackN, but it refuses to extract due to SFX files lacking the typical CAB identifiers.
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class MicrosoftCABSFX : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class MicrosoftCABSFX : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -29,7 +28,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("wextract_cleanup")))
+                if (strs.Exists(s => s.Contains("wextract_cleanup")))
                     return $"Microsoft CAB SFX {GetVersion(pex)}";
             }
 
@@ -39,7 +38,7 @@ namespace BinaryObjectScanner.Packer
             {
                 // This detects a different but similar type of SFX that uses Microsoft CAB files.
                 // Further research is needed to see if it's just a different version or entirely separate.
-                if (strs.Any(s => s.Contains("MSCFu")))
+                if (strs.Exists(s => s.Contains("MSCFu")))
                     return $"Microsoft CAB SFX {GetVersion(pex)}";
             }
 
@@ -47,9 +46,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/NSIS.cs

@@ -1,14 +1,13 @@
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
-    public class NSIS : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class NSIS : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -23,7 +22,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("NullsoftInst")))
+                if (strs.Exists(s => s.Contains("NullsoftInst")))
                     return "NSIS";
             }
 
@@ -31,9 +30,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/NeoLite.cs

@@ -13,11 +13,11 @@ namespace BinaryObjectScanner.Packer
     /// PEiD scanning definitions that include NeoLite: https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
     /// Website listing various packers, including NeoLite: http://protools.narod.ru/packers.htm
     /// </summary>
-    public class NeoLite : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class NeoLite : IExtractableExecutable<PortableExecutable>
     {
         // TODO: Find samples of NeoLite 1.X.
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -36,9 +36,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/PECompact.cs

@@ -5,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Better version detection - https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
     // TODO: Add extraction
-    public class PECompact : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class PECompact : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -41,9 +41,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/Petite.cs

@@ -5,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class PEtite : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class PEtite : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -24,9 +24,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/SetupFactory.cs

@@ -7,10 +7,10 @@ namespace BinaryObjectScanner.Packer
     // TODO: Add extraction, which is possible but the only tools available that can
     // do this seem to be Universal Extractor 2 and InstallExplorer (https://totalcmd.net/plugring/InstallExplorer.html)
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class SetupFactory : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class SetupFactory : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -38,9 +38,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/SevenZipSFX.cs

@@ -1,20 +1,13 @@
-using System;
-using System.IO;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
-#if NET462_OR_GREATER || NETCOREAPP
-using SharpCompress.Archives;
-using SharpCompress.Archives.SevenZip;
-using SharpCompress.Readers;
-#endif
 
 namespace BinaryObjectScanner.Packer
 {
-    public class SevenZipSFX : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class SevenZipSFX : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -24,7 +17,7 @@ namespace BinaryObjectScanner.Packer
             // Get the assembly description, if possible
             if (pex.AssemblyDescription?.StartsWith("7-Zip Self-extracting Archive") == true)
                 return $"7-Zip SFX {pex.AssemblyDescription.Substring("7-Zip Self-extracting Archive ".Length)}";
-            
+
             // Get the file description, if it exists
             if (pex.FileDescription?.Equals("7z SFX") == true)
                 return "7-Zip SFX";
@@ -51,59 +44,10 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-#if NET462_OR_GREATER || NETCOREAPP
-            try
-            {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (SevenZipArchive sevenZipFile = SevenZipArchive.Open(file, new ReaderOptions() { LookForHeader = true }))
-                {
-                    foreach (var entry in sevenZipFile.Entries)
-                    {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
-
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
-
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
-
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-                    }
-                }
-
-                return tempPath;
-            }
-            catch (Exception ex)
-            {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
-            }
-#else
-            return null;
-#endif
+            var sevenZip = new FileType.SevenZip();
+            return sevenZip.Extract(file, outDir, lookForHeader: true, includeDebug);
         }
     }
 }

BinaryObjectScanner/Packer/Shrinker.cs

@@ -5,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class Shrinker : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class Shrinker : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -25,9 +25,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/UPX.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using BinaryObjectScanner.Interfaces;
@@ -9,14 +8,14 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class UPX : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class UPX : IExtractableExecutable<PortableExecutable>
     {
         private static readonly Regex _oldUpxVersionMatch = new Regex(@"\$Id: UPX (.*?) Copyright \(C\)", RegexOptions.Compiled);
 
         private static readonly Regex _upxVersionMatch = new Regex(@"^([0-9]\.[0-9]{2})$", RegexOptions.Compiled);
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -24,13 +23,13 @@ namespace BinaryObjectScanner.Packer
                 return null;
 
             // Check header padding strings
-            if (pex.HeaderPaddingStrings?.Any() == true)
+            if (pex.HeaderPaddingStrings != null && pex.HeaderPaddingStrings.Count > 0)
             {
-                var match = pex.HeaderPaddingStrings.FirstOrDefault(s => s.Contains("UPX!"));
+                var match = pex.HeaderPaddingStrings.Find(s => s.Contains("UPX!"));
                 //if (match != null)
                 //    return "UPX";
 
-                match = pex.HeaderPaddingStrings.FirstOrDefault(s => s.StartsWith("$Id: UPX"));
+                match = pex.HeaderPaddingStrings.Find(s => s.StartsWith("$Id: UPX"));
                 if (match != null)
                 {
                     var regexMatch = _oldUpxVersionMatch.Match(match);
@@ -40,8 +39,8 @@ namespace BinaryObjectScanner.Packer
                         return "UPX (Unknown Version)";
                 }
 
-                match = pex.HeaderPaddingStrings.FirstOrDefault(s => _upxVersionMatch.IsMatch(s));
-                if (match != null && pex.HeaderPaddingStrings.Any(s => s == "UPX!"))
+                match = pex.HeaderPaddingStrings.Find(s => _upxVersionMatch.IsMatch(s));
+                if (match != null && pex.HeaderPaddingStrings.Exists(s => s == "UPX!"))
                 {
                     var regexMatch = _upxVersionMatch.Match(match);
                     if (regexMatch.Success)
@@ -49,7 +48,7 @@ namespace BinaryObjectScanner.Packer
                     else
                         return "UPX (Unknown Version)";
                 }
-                else if (match != null && pex.HeaderPaddingStrings.Any(s => s == "NOS "))
+                else if (match != null && pex.HeaderPaddingStrings.Exists(s => s == "NOS "))
                 {
                     var regexMatch = _upxVersionMatch.Match(match);
                     if (regexMatch.Success)
@@ -63,9 +62,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
 
         public static string GetVersion(string file, byte[] fileContent, List<int> positions)

BinaryObjectScanner/Packer/WinRARSFX.cs

@@ -1,20 +1,13 @@
-using System;
-using System.IO;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
-#if NET462_OR_GREATER || NETCOREAPP
-using SharpCompress.Archives;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Readers;
-#endif
 
 namespace BinaryObjectScanner.Packer
 {
-    public class WinRARSFX : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class WinRARSFX : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -33,59 +26,10 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-#if NET462_OR_GREATER || NETCOREAPP
-            try
-            {
-                // Should be using stream instead of file, but stream fails to extract anything. My guess is that the executable portion of the archive is causing stream to fail, but not file.
-                using (RarArchive rarFile = RarArchive.Open(file, new ReaderOptions() { LookForHeader = true }))
-                {
-                    if (!rarFile.IsComplete)
-                        return null;
-
-                    string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                    Directory.CreateDirectory(tempPath);
-
-                    foreach (var entry in rarFile.Entries)
-                    {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
-
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
-
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
-
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-                    }
-
-                    return tempPath;
-                }
-            }
-            catch (Exception ex)
-            {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
-            }
-#else
-            return null;
-#endif
+            var rar = new FileType.RAR();
+            return rar.Extract(file, outDir, lookForHeader: true, includeDebug);
         }
     }
 }

BinaryObjectScanner/Packer/WinZipSFX.cs

@@ -1,20 +1,14 @@
-using System;
-using System.IO;
 using System.Linq;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
-#if NET462_OR_GREATER || NETCOREAPP
-using SharpCompress.Archives;
-using SharpCompress.Archives.Zip;
-#endif
 
 namespace BinaryObjectScanner.Packer
 {
-    public class WinZipSFX : IExtractableNewExecutable, IExtractablePortableExecutable, INewExecutableCheck, IPortableExecutableCheck
+    public class WinZipSFX : IExtractableExecutable<NewExecutable>, IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckNewExecutable(string file, NewExecutable nex, bool includeDebug)
+        public string? CheckExecutable(string file, NewExecutable nex, bool includeDebug)
         {
             // If the resident-name table doesnt exist
             if (nex.Model.ResidentNameTable == null)
@@ -41,7 +35,7 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -66,66 +60,20 @@ namespace BinaryObjectScanner.Packer
         // TODO: Find a way to generically detect 2.X versions and improve exact version detection for SFX PE versions bundled with WinZip 11+
 
         /// <inheritdoc/>
-        public string? Extract(string file, NewExecutable nex, bool includeDebug)
-            => Extract(file, includeDebug);
+        public bool Extract(string file, NewExecutable nex, string outDir, bool includeDebug)
+            => Extract(file, outDir, includeDebug);
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
-            => Extract(file, includeDebug);
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
+            => Extract(file, outDir, includeDebug);
 
         /// <summary>
         /// Handle common extraction between executable types
         /// </summary>
-        public static string? Extract(string file, bool includeDebug)
+        public static bool Extract(string file, string outDir, bool includeDebug)
         {
-#if NET462_OR_GREATER || NETCOREAPP
-            try
-            {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                using (ZipArchive zipFile = ZipArchive.Open(file))
-                {
-                    foreach (var entry in zipFile.Entries)
-                    {
-                        try
-                        {
-                            // If the entry is a directory
-                            if (entry.IsDirectory)
-                                continue;
-
-                            // If the entry has an invalid key
-                            if (entry.Key == null)
-                                continue;
-
-                            // If we have a partial entry due to an incomplete multi-part archive, skip it
-                            if (!entry.IsComplete)
-                                continue;
-
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            var directoryName = Path.GetDirectoryName(tempFile);
-                            if (directoryName != null && !Directory.Exists(directoryName))
-                                Directory.CreateDirectory(directoryName);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-                    }
-                }
-
-                return tempPath;
-            }
-            catch (Exception ex)
-            {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
-            }
-#else
-            return null;
-#endif
+            var pkzip = new FileType.PKZIP();
+            return pkzip.Extract(file, outDir, lookForHeader: true, includeDebug);
         }
 
         /// <summary>
@@ -796,14 +744,14 @@ namespace BinaryObjectScanner.Packer
                 "WZIPSE32.exe" => "Unknown Version (32-bit)",// TODO: Find starting version
                 "SI32LPG.SFX" => "Unknown Version (32-bit)",// TODO: Find starting version
                 "ST32E.WZE" => "Unknown Version (32-bit)",// TODO: Find starting version
-                                                          
+
                 // Personal Edition
                 "VW95LE.SFX" => "Unknown Version before Personal Edition Build 1285 (32-bit)",
                 "PE32E.SFX" => "Unknown Version after Personal Edition Build 1285 (32-bit)",
                 "wzsepe32.exe" => "Unknown Version Personal Edition (32-bit)",// TODO: Find starting version
                 "SI32PE.SFX" => "Unknown Version Personal Edition (32-bit)",// TODO: Find starting version
                 "SI32LPE.SFX" => "Unknown Version Personal Edition (32-bit)",// TODO: Find starting version
-                                                                             
+
                 // Software Installation
                 "VW95SRE.SFX" => "Unknown Version before Software Installation 2.1 (32-bit)",
                 "SI32E.SFX" => "Unknown Version after Software Installation 2.1 (32-bit)",

BinaryObjectScanner/Packer/WiseInstaller.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.IO.Extensions;
 using SabreTools.Matching;
@@ -13,10 +12,10 @@ using WiseUnpacker.EWISE;
 namespace BinaryObjectScanner.Packer
 {
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class WiseInstaller : IExtractableNewExecutable, IExtractablePortableExecutable, INewExecutableCheck, IPortableExecutableCheck
+    public class WiseInstaller : IExtractableExecutable<NewExecutable>, IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckNewExecutable(string file, NewExecutable nex, bool includeDebug)
+        public string? CheckExecutable(string file, NewExecutable nex, bool includeDebug)
         {
             // If we match a known header
             if (MatchesNEVersion(nex) != null)
@@ -42,7 +41,7 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -59,7 +58,7 @@ namespace BinaryObjectScanner.Packer
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("WiseMain")))
+                if (strs.Exists(s => s.Contains("WiseMain")))
                     return "Wise Installation Wizard Module";
             }
 
@@ -67,7 +66,7 @@ namespace BinaryObjectScanner.Packer
             strs = pex.GetFirstSectionStrings(".rdata");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("WiseMain")))
+                if (strs.Exists(s => s.Contains("WiseMain")))
                     return "Wise Installation Wizard Module";
             }
 
@@ -75,52 +74,36 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, NewExecutable nex, bool includeDebug)
+        public bool Extract(string file, NewExecutable nex, string outDir, bool includeDebug)
         {
-            string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-            Directory.CreateDirectory(tempPath);
+            Directory.CreateDirectory(outDir);
 
             try
             {
-                // TODO: Try to find where the file data lives and how to get it
-                if (!Extractor.ExtractTo(file, tempPath))
-                {
-                    try
-                    {
-                        Directory.Delete(tempPath, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        if (includeDebug) Console.WriteLine(ex);
-                    }
-
-                    return null;
-                }
+                return Extractor.ExtractTo(file, outDir);
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
-
-            return tempPath;
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             try
             {
                 // Get the matching PE format
                 var format = GetPEFormat(pex);
                 if (format == null)
-                    return null;
+                    return false;
 
                 // Get the overlay data for easier reading
                 int overlayOffset = 0, dataStart = 0;
                 var overlayData = pex.OverlayData;
                 if (overlayData == null)
-                    return null;
+                    return false;
 
                 // Skip over the additional DLL name, if we expect it
                 if (format.Dll)
@@ -173,45 +156,34 @@ namespace BinaryObjectScanner.Packer
 
                 // If the first entry is PKZIP, we assume it's an embedded zipfile
                 var magic = overlayData.ReadBytes(ref overlayOffset, 4); overlayOffset -= 4;
+#if NET20
+                bool pkzip = Extensions.StartsWith(magic, new byte?[] { (byte)'P', (byte)'K' });
+#else
                 bool pkzip = magic?.StartsWith(new byte?[] { (byte)'P', (byte)'K' }) ?? false;
+#endif
 
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
+                // Create the output directory
+                Directory.CreateDirectory(outDir);
 
                 // If we have PKZIP
                 if (pkzip)
                 {
-                    string tempFile = Path.Combine(tempPath, "WISEDATA.zip");
-                    using (Stream tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
-                    {
-                        tempStream.Write(overlayData, overlayOffset, overlayData.Length - overlayOffset);
-                    }
+                    string tempFile = Path.Combine(outDir, "WISEDATA.zip");
+                    using Stream tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
+                    tempStream.Write(overlayData, overlayOffset, overlayData.Length - overlayOffset);
+                    return true;
                 }
 
                 // If we have DEFLATE -- TODO: Port implementation here or use DeflateStream
                 else
                 {
-                    if (!Extractor.ExtractTo(file, tempPath))
-                    {
-                        try
-                        {
-                            Directory.Delete(tempPath, true);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-
-                        return null;
-                    }
+                    return Extractor.ExtractTo(file, outDir);
                 }
-
-                return tempPath;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
             }
         }
 

BinaryObjectScanner/Progress.cs

@@ -8,6 +8,16 @@ using System.Diagnostics;
 
 namespace System
 {
+    /// <summary>Defines a provider for progress updates.</summary>
+    /// <typeparam name="T">The type of progress update value.</typeparam>
+    /// <see href="https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/IProgress.cs"/>
+    public interface IProgress<in T>
+    {
+        /// <summary>Reports a progress update.</summary>
+        /// <param name="value">The value of the updated progress.</param>
+        void Report(T value);
+    }
+
     /// <summary>
     /// Provides an IProgress{T} that invokes callbacks for each reported progress value.
     /// </summary>

BinaryObjectScanner/Protection/ActiveMARK.cs

@@ -9,7 +9,7 @@ using SabreTools.Serialization.Wrappers;
 namespace BinaryObjectScanner.Protection
 {
     // TODO: Figure out how to get version numbers
-    public class ActiveMARK : IContentCheck, IPortableExecutableCheck
+    public class ActiveMARK : IContentCheck, IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
         public string? CheckContents(string file, byte[] fileContent, bool includeDebug)
@@ -35,7 +35,7 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -45,45 +45,55 @@ namespace BinaryObjectScanner.Protection
             // Get the entry point data, if it exists
             if (pex.EntryPointData != null)
             {
+#if NET20
                 // Found in "Zuma.exe"
-                if (pex.EntryPointData.StartsWith(new byte?[] { 0x89, 0x25, 0x04, 0xF0, 0x86, 0x00, 0x68, 0x30 }))
+                if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, 0x04, 0xF0, 0x86, 0x00, 0x68, 0x30 }))
                     return "ActiveMark v5.3.1078 (Packer Version)";
 
                 // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x89, 0x25, null, null, null, null, 0xEB }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, null, null, null, null, 0xEB }))
                     return "ActiveMark -> Trymedia Systems Inc. (Unconfirmed - Please report to us on Github)";
-
-                // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x89, 0x25, null, null, null, null, 0x33, 0xED, 0x55, 0x8B, 0xEC, 0xE8, null, null, null, null, 0x8B, 0xD0, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0x89, 0x15, null, null, null, null, 0x8B, 0xD0, 0xC1, 0xEA, 0x08, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0xA3, null, null, null, null, 0xD1, 0xE0, 0x0F, 0x93, 0xC3, 0x33, 0xC0, 0x8A, 0xC3, 0xA3, null, null, null, null, 0x68, 0xFF, 0x00, 0x00, 0x00, 0xE8, null, null, null, null, 0x6A, 0x00, 0xE8, null, null, null, null, 0xA3, null, null, null, null, 0xBB, null, null, null, null, 0xC7, 0x03, 0x44, 0x00, 0x00, 0x00 }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, null, null, null, null, 0x33, 0xED, 0x55, 0x8B, 0xEC, 0xE8, null, null, null, null, 0x8B, 0xD0, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0x89, 0x15, null, null, null, null, 0x8B, 0xD0, 0xC1, 0xEA, 0x08, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0xA3, null, null, null, null, 0xD1, 0xE0, 0x0F, 0x93, 0xC3, 0x33, 0xC0, 0x8A, 0xC3, 0xA3, null, null, null, null, 0x68, 0xFF, 0x00, 0x00, 0x00, 0xE8, null, null, null, null, 0x6A, 0x00, 0xE8, null, null, null, null, 0xA3, null, null, null, null, 0xBB, null, null, null, null, 0xC7, 0x03, 0x44, 0x00, 0x00, 0x00 }))
                     return "ActiveMark -> Trymedia Systems Inc. (Unconfirmed - Please report to us on Github)";
-
-                // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67 }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67 }))
                     return "ActiveMARK 5.x -> Trymedia Systems Inc. (h) (Unconfirmed - Please report to us on Github)";
-
-                // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0x0D, 0x0A, 0x50, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x00, 0x57, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67 }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0x0D, 0x0A, 0x50, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x00, 0x57, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67 }))
                     return "ActiveMARK 5.x -> Trymedia Systems,Inc. (Unconfirmed - Please report to us on Github)";
-
-                // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x79, 0x11, 0x7F, 0xAB, 0x9A, 0x4A, 0x83, 0xB5, 0xC9, 0x6B, 0x1A, 0x48, 0xF9, 0x27, 0xB4, 0x25 }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x79, 0x11, 0x7F, 0xAB, 0x9A, 0x4A, 0x83, 0xB5, 0xC9, 0x6B, 0x1A, 0x48, 0xF9, 0x27, 0xB4, 0x25 }))
                     return "ActiveMARK[TM] (Unconfirmed - Please report to us on Github)";
-
-                // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0x79, 0x07, 0x0F, 0xB7, 0x07, 0x47, 0x50, 0x47, 0xB9, 0x57, 0x48, 0xF2, 0xAE, 0x55, 0xFF, 0x96, 0x84, null, 0x00, 0x00, 0x09, 0xC0, 0x74, 0x07, 0x89, 0x03, 0x83, 0xC3, 0x04, 0xEB, 0xD8, 0xFF, 0x96, 0x88, null, 0x00, 0x00, 0x61, 0xE9, null, null, null, 0xFF }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x79, 0x07, 0x0F, 0xB7, 0x07, 0x47, 0x50, 0x47, 0xB9, 0x57, 0x48, 0xF2, 0xAE, 0x55, 0xFF, 0x96, 0x84, null, 0x00, 0x00, 0x09, 0xC0, 0x74, 0x07, 0x89, 0x03, 0x83, 0xC3, 0x04, 0xEB, 0xD8, 0xFF, 0x96, 0x88, null, 0x00, 0x00, 0x61, 0xE9, null, null, null, 0xFF }))
                     return "ActiveMARK[TM] R5.31.1140 -> Trymedia (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0xBE, 0x48, 0x01, 0x40, 0x00, 0xAD, 0x8B, 0xF8, 0x95, 0xA5, 0x33, 0xC0, 0x33, 0xC9, 0xAB, 0x48, 0xAB, 0xF7, 0xD8, 0xB1, 0x04, 0xF3, 0xAB, 0xC1, 0xE0, 0x0A, 0xB5, 0x1C, 0xF3, 0xAB, 0xAD, 0x50, 0x97, 0x51, 0xAD, 0x87, 0xF5, 0x58, 0x8D, 0x54, 0x86, 0x5C, 0xFF, 0xD5, 0x72, 0x5A, 0x2C, 0x03, 0x73, 0x02, 0xB0, 0x00, 0x3C, 0x07, 0x72, 0x02, 0x2C, 0x03, 0x50, 0x0F, 0xB6, 0x5F, 0xFF, 0xC1, 0xE3, 0x03, 0xB3, 0x00, 0x8D, 0x1C, 0x5B, 0x8D, 0x9C, 0x9E, 0x0C, 0x10, 0x00, 0x00, 0xB0, 0x01, 0x67, 0xE3, 0x29, 0x8B, 0xD7, 0x2B, 0x56, 0x0C, 0x8A, 0x2A, 0x33, 0xD2, 0x84, 0xE9, 0x0F, 0x95, 0xC6, 0x52, 0xFE, 0xC6, 0x8A, 0xD0, 0x8D, 0x14, 0x93, 0xFF, 0xD5, 0x5A, 0x9F, 0x12, 0xC0, 0xD0, 0xE9, 0x74, 0x0E, 0x9E, 0x1A, 0xF2, 0x74, 0xE4, 0xB4, 0x00, 0x33, 0xC9, 0xB5, 0x01, 0xFF, 0x55, 0xCC, 0x33, 0xC9, 0xE9, 0xDF, 0x00, 0x00, 0x00, 0x8B, 0x5E, 0x0C, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x73, 0x50, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x1B, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x2B, 0x3C, 0x07, 0xB0, 0x09, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x8B, 0xC7, 0x2B, 0x46, 0x0C, 0xB1, 0x80, 0x8A, 0x00, 0xEB, 0xCF, 0x83, 0xC2, 0x60, 0xFF, 0xD5, 0x87, 0x5E, 0x10, 0x73, 0x0D, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x87, 0x5E, 0x14, 0x73, 0x03, 0x87, 0x5E, 0x18, 0x3C, 0x07, 0xB0, 0x08, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x53, 0x8D, 0x96, 0x7C, 0x07, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x5B, 0x91, 0xEB, 0x77, 0x3C, 0x07, 0xB0, 0x07, 0x72, 0x02, 0xB0, 0x0A, 0x50, 0x87, 0x5E, 0x10, 0x87, 0x5E, 0x14, 0x89, 0x5E, 0x18, 0x8D, 0x96, 0xC4, 0x0B, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x50, 0x48 }))
+                    return "ActiveMARK 5.x -> Trymedia Systems,Inc. (h) (Unconfirmed - Please report to us on Github)";
+#else
+                // Found in "Zuma.exe"
+                if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, 0x04, 0xF0, 0x86, 0x00, 0x68, 0x30 }))
+                    return "ActiveMark v5.3.1078 (Packer Version)";
 
                 // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-                else if (pex.EntryPointData.StartsWith(new byte?[] { 0xBE, 0x48, 0x01, 0x40, 0x00, 0xAD, 0x8B, 0xF8, 0x95, 0xA5, 0x33, 0xC0, 0x33, 0xC9, 0xAB, 0x48, 0xAB, 0xF7, 0xD8, 0xB1, 0x04, 0xF3, 0xAB, 0xC1, 0xE0, 0x0A, 0xB5, 0x1C, 0xF3, 0xAB, 0xAD, 0x50, 0x97, 0x51, 0xAD, 0x87, 0xF5, 0x58, 0x8D, 0x54, 0x86, 0x5C, 0xFF, 0xD5, 0x72, 0x5A, 0x2C, 0x03, 0x73, 0x02, 0xB0, 0x00, 0x3C, 0x07, 0x72, 0x02, 0x2C, 0x03, 0x50, 0x0F, 0xB6, 0x5F, 0xFF, 0xC1, 0xE3, 0x03, 0xB3, 0x00, 0x8D, 0x1C, 0x5B, 0x8D, 0x9C, 0x9E, 0x0C, 0x10, 0x00, 0x00, 0xB0, 0x01, 0x67, 0xE3, 0x29, 0x8B, 0xD7, 0x2B, 0x56, 0x0C, 0x8A, 0x2A, 0x33, 0xD2, 0x84, 0xE9, 0x0F, 0x95, 0xC6, 0x52, 0xFE, 0xC6, 0x8A, 0xD0, 0x8D, 0x14, 0x93, 0xFF, 0xD5, 0x5A, 0x9F, 0x12, 0xC0, 0xD0, 0xE9, 0x74, 0x0E, 0x9E, 0x1A, 0xF2, 0x74, 0xE4, 0xB4, 0x00, 0x33, 0xC9, 0xB5, 0x01, 0xFF, 0x55, 0xCC, 0x33, 0xC9, 0xE9, 0xDF, 0x00, 0x00, 0x00, 0x8B, 0x5E, 0x0C, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x73, 0x50, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x1B, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x2B, 0x3C, 0x07, 0xB0, 0x09, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x8B, 0xC7, 0x2B, 0x46, 0x0C, 0xB1, 0x80, 0x8A, 0x00, 0xEB, 0xCF, 0x83, 0xC2, 0x60, 0xFF, 0xD5, 0x87, 0x5E, 0x10, 0x73, 0x0D, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x87, 0x5E, 0x14, 0x73, 0x03, 0x87, 0x5E, 0x18, 0x3C, 0x07, 0xB0, 0x08, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x53, 0x8D, 0x96, 0x7C, 0x07, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x5B, 0x91, 0xEB, 0x77, 0x3C, 0x07, 0xB0, 0x07, 0x72, 0x02, 0xB0, 0x0A, 0x50, 0x87, 0x5E, 0x10, 0x87, 0x5E, 0x14, 0x89, 0x5E, 0x18, 0x8D, 0x96, 0xC4, 0x0B, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x50, 0x48 }))
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, null, null, null, null, 0xEB }))
+                    return "ActiveMark -> Trymedia Systems Inc. (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x89, 0x25, null, null, null, null, 0x33, 0xED, 0x55, 0x8B, 0xEC, 0xE8, null, null, null, null, 0x8B, 0xD0, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0x89, 0x15, null, null, null, null, 0x8B, 0xD0, 0xC1, 0xEA, 0x08, 0x81, 0xE2, 0xFF, 0x00, 0x00, 0x00, 0xA3, null, null, null, null, 0xD1, 0xE0, 0x0F, 0x93, 0xC3, 0x33, 0xC0, 0x8A, 0xC3, 0xA3, null, null, null, null, 0x68, 0xFF, 0x00, 0x00, 0x00, 0xE8, null, null, null, null, 0x6A, 0x00, 0xE8, null, null, null, null, 0xA3, null, null, null, null, 0xBB, null, null, null, null, 0xC7, 0x03, 0x44, 0x00, 0x00, 0x00 }))
+                    return "ActiveMark -> Trymedia Systems Inc. (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67 }))
+                    return "ActiveMARK 5.x -> Trymedia Systems Inc. (h) (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x20, 0x2D, 0x2D, 0x4D, 0x50, 0x52, 0x4D, 0x4D, 0x47, 0x56, 0x41, 0x2D, 0x2D, 0x00, 0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x6F, 0x78, 0x41, 0x00, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0x0D, 0x0A, 0x50, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x00, 0x57, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67 }))
+                    return "ActiveMARK 5.x -> Trymedia Systems,Inc. (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x79, 0x11, 0x7F, 0xAB, 0x9A, 0x4A, 0x83, 0xB5, 0xC9, 0x6B, 0x1A, 0x48, 0xF9, 0x27, 0xB4, 0x25 }))
+                    return "ActiveMARK[TM] (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0x79, 0x07, 0x0F, 0xB7, 0x07, 0x47, 0x50, 0x47, 0xB9, 0x57, 0x48, 0xF2, 0xAE, 0x55, 0xFF, 0x96, 0x84, null, 0x00, 0x00, 0x09, 0xC0, 0x74, 0x07, 0x89, 0x03, 0x83, 0xC3, 0x04, 0xEB, 0xD8, 0xFF, 0x96, 0x88, null, 0x00, 0x00, 0x61, 0xE9, null, null, null, 0xFF }))
+                    return "ActiveMARK[TM] R5.31.1140 -> Trymedia (Unconfirmed - Please report to us on Github)";
+                else if (Extensions.StartsWith(pex.EntryPointData, new byte?[] { 0xBE, 0x48, 0x01, 0x40, 0x00, 0xAD, 0x8B, 0xF8, 0x95, 0xA5, 0x33, 0xC0, 0x33, 0xC9, 0xAB, 0x48, 0xAB, 0xF7, 0xD8, 0xB1, 0x04, 0xF3, 0xAB, 0xC1, 0xE0, 0x0A, 0xB5, 0x1C, 0xF3, 0xAB, 0xAD, 0x50, 0x97, 0x51, 0xAD, 0x87, 0xF5, 0x58, 0x8D, 0x54, 0x86, 0x5C, 0xFF, 0xD5, 0x72, 0x5A, 0x2C, 0x03, 0x73, 0x02, 0xB0, 0x00, 0x3C, 0x07, 0x72, 0x02, 0x2C, 0x03, 0x50, 0x0F, 0xB6, 0x5F, 0xFF, 0xC1, 0xE3, 0x03, 0xB3, 0x00, 0x8D, 0x1C, 0x5B, 0x8D, 0x9C, 0x9E, 0x0C, 0x10, 0x00, 0x00, 0xB0, 0x01, 0x67, 0xE3, 0x29, 0x8B, 0xD7, 0x2B, 0x56, 0x0C, 0x8A, 0x2A, 0x33, 0xD2, 0x84, 0xE9, 0x0F, 0x95, 0xC6, 0x52, 0xFE, 0xC6, 0x8A, 0xD0, 0x8D, 0x14, 0x93, 0xFF, 0xD5, 0x5A, 0x9F, 0x12, 0xC0, 0xD0, 0xE9, 0x74, 0x0E, 0x9E, 0x1A, 0xF2, 0x74, 0xE4, 0xB4, 0x00, 0x33, 0xC9, 0xB5, 0x01, 0xFF, 0x55, 0xCC, 0x33, 0xC9, 0xE9, 0xDF, 0x00, 0x00, 0x00, 0x8B, 0x5E, 0x0C, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x73, 0x50, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x1B, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x72, 0x2B, 0x3C, 0x07, 0xB0, 0x09, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x8B, 0xC7, 0x2B, 0x46, 0x0C, 0xB1, 0x80, 0x8A, 0x00, 0xEB, 0xCF, 0x83, 0xC2, 0x60, 0xFF, 0xD5, 0x87, 0x5E, 0x10, 0x73, 0x0D, 0x83, 0xC2, 0x30, 0xFF, 0xD5, 0x87, 0x5E, 0x14, 0x73, 0x03, 0x87, 0x5E, 0x18, 0x3C, 0x07, 0xB0, 0x08, 0x72, 0x02, 0xB0, 0x0B, 0x50, 0x53, 0x8D, 0x96, 0x7C, 0x07, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x5B, 0x91, 0xEB, 0x77, 0x3C, 0x07, 0xB0, 0x07, 0x72, 0x02, 0xB0, 0x0A, 0x50, 0x87, 0x5E, 0x10, 0x87, 0x5E, 0x14, 0x89, 0x5E, 0x18, 0x8D, 0x96, 0xC4, 0x0B, 0x00, 0x00, 0xFF, 0x55, 0xD0, 0x50, 0x48 }))
                     return "ActiveMARK 5.x -> Trymedia Systems,Inc. (h) (Unconfirmed - Please report to us on Github)";
+#endif
             }
 
             // Get the .data section strings, if they exist
             var strs = pex.GetLastSectionStrings(".data");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("MPRMMGVA"))
-                    && strs.Any(s => s.Contains("This application cannot run with an active debugger in memory.")))
+                if (strs.Exists(s => s.Contains("MPRMMGVA"))
+                    && strs.Exists(s => s.Contains("This application cannot run with an active debugger in memory.")))
                 {
                     return "ActiveMARK 6.x";
                 }
@@ -103,7 +113,7 @@ namespace BinaryObjectScanner.Protection
             // Get the overlay data, if it exists
             if (pex.OverlayStrings != null)
             {
-                if (pex.OverlayStrings.Any(s => s.Contains("TMSAMVOH")))
+                if (pex.OverlayStrings.Exists(s => s.Contains("TMSAMVOH")))
                     return "ActiveMARK";
             }
 
@@ -111,7 +121,7 @@ namespace BinaryObjectScanner.Protection
             strs = pex.GetLastSectionStrings(".bss");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("TMSAMVOF")))
+                if (strs.Exists(s => s.Contains("TMSAMVOF")))
                     return "ActiveMARK";
             }
 

BinaryObjectScanner/Protection/AegiSoft.cs

@@ -18,10 +18,10 @@ namespace BinaryObjectScanner.Protection
     /// https://pitchbook.com/profiles/company/118805-59
     /// https://web.archive.org/web/19990417191351/http://www.aegisoft.com:80/
     /// </summary>
-    public class AegiSoft : IPathCheck, IPortableExecutableCheck
+    public class AegiSoft : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/AlphaROM.cs

@@ -1,5 +1,4 @@
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -40,10 +39,10 @@ namespace BinaryObjectScanner.Protection
     //      - SETTEC0000SETTEC1111
     //      - SOFTWARE\SETTEC
     // TODO: Are there version numbers?
-    public class AlphaROM : IPortableExecutableCheck
+    public class AlphaROM : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // TODO: Add support for detecting Alpha-ROM found in older games made with the RealLive engine. 
             // TODO: Add version detection for Alpha-ROM.
@@ -57,10 +56,10 @@ namespace BinaryObjectScanner.Protection
             var strs = pex.GetFirstSectionStrings(".data") ?? pex.GetFirstSectionStrings("DATA");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("\\SETTEC")))
+                if (strs.Exists(s => s.Contains("\\SETTEC")))
                     return "Alpha-ROM";
 
-                if (strs.Any(s => s.Contains("SETTEC0000")))
+                if (strs.Exists(s => s.Contains("SETTEC0000")))
                     return "Alpha-ROM";
             }
 
@@ -68,13 +67,13 @@ namespace BinaryObjectScanner.Protection
             strs = pex.GetFirstSectionStrings(".rdata");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("This Game is Japan Only")))
+                if (strs.Exists(s => s.Contains("This Game is Japan Only")))
                     return "Alpha-ROM";
                 // Found in "Filechk.exe" in Redump entry 115358.
-                if (strs.Any(s => s.Contains("AlphaCheck.exe")))
+                if (strs.Exists(s => s.Contains("AlphaCheck.exe")))
                     return "Alpha-ROM";
                 // Found in "Uninstall.exe" in Redump entry 115358.
-                if (strs.Any(s => s.Contains("AlphaCheck.dat")))
+                if (strs.Exists(s => s.Contains("AlphaCheck.dat")))
                     return "Alpha-ROM";
             }
 
@@ -82,7 +81,7 @@ namespace BinaryObjectScanner.Protection
             if (pex.OverlayStrings != null)
             {
                 // Found in Redump entry 84122.
-                if (pex.OverlayStrings.Any(s => s.Contains("SETTEC0000")))
+                if (pex.OverlayStrings.Exists(s => s.Contains("SETTEC0000")))
                     return "Alpha-ROM";
             }
 

BinaryObjectScanner/Protection/Armadillo.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using System;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -18,10 +18,10 @@ namespace BinaryObjectScanner.Protection
     // TODO: Add version checking, if possible
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
     
-    public class Armadillo : IExtractablePortableExecutable, IPortableExecutableCheck
+    public class Armadillo : IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -36,13 +36,13 @@ namespace BinaryObjectScanner.Protection
             // Loop through all "extension" sections -- usually .data1 or .text1
             if (pex.SectionNames != null)
             {
-                foreach (var sectionName in pex.SectionNames.Where(s => s != null && s.EndsWith("1")))
+                foreach (var sectionName in Array.FindAll(pex.SectionNames, s => s != null && s.EndsWith("1")))
                 {
                     // Get the section strings, if they exist
                     var strs = pex.GetFirstSectionStrings(sectionName);
                     if (strs != null)
                     {
-                        if (strs.Any(s => s.Contains("ARMDEBUG")))
+                        if (strs.Exists(s => s.Contains("ARMDEBUG")))
                             return "Armadillo";
                     }
                 }
@@ -52,9 +52,9 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, PortableExecutable pex, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Protection/ByteShield.cs

@@ -38,10 +38,10 @@ namespace BinaryObjectScanner.Protection
     /// https://www.ftc.gov/sites/default/files/documents/public_comments/ftc-town-hall-address-digital-rights-management-technologies-event-takes-place-wednesday-march-25/539814-00707.pdf
     /// https://www.gamesindustry.biz/byteshield-drm-system-now-protecting-over-200-games
     /// </summary>
-    public class ByteShield : IPortableExecutableCheck, IPathCheck
+    public class ByteShield : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -95,7 +95,7 @@ namespace BinaryObjectScanner.Protection
             if (strs != null)
             {
                 // Found in "LineRider2.exe" in Redump entry 6236
-                if (strs.Any(s => s?.Contains("ByteShield") == true))
+                if (strs.Exists(s => s?.Contains("ByteShield") == true))
                     return "ByteShield";
             }
 
@@ -104,15 +104,15 @@ namespace BinaryObjectScanner.Protection
             if (strs != null)
             {
                 // Found in "ByteShield.dll" in Redump entry 6236
-                if (strs.Any(s => s?.Contains("Byte|Shield") == true))
+                if (strs.Exists(s => s?.Contains("Byte|Shield") == true))
                     return "ByteShield Component Module";
 
                 // Found in "ByteShield.dll" in Redump entry 6236
-                else if (strs.Any(s => s?.Contains("Byteshield0") == true))
+                else if (strs.Exists(s => s?.Contains("Byteshield0") == true))
                     return "ByteShield Component Module";
 
                 // Found in "ByteShield.dll" in Redump entry 6236
-                else if (strs.Any(s => s?.Contains("ByteShieldLoader") == true))
+                else if (strs.Exists(s => s?.Contains("ByteShieldLoader") == true))
                     return "ByteShield Component Module";
             }
 
@@ -122,7 +122,7 @@ namespace BinaryObjectScanner.Protection
             {
                 // TODO: Figure out if this specifically indicates if the file is encrypted
                 // Found in "LineRider2.bbz" in Redump entry 6236
-                if (strs.Any(s => s?.Contains("ByteShield") == true))
+                if (strs.Exists(s => s?.Contains("ByteShield") == true))
                     return "ByteShield";
             }
 

BinaryObjectScanner/Protection/CDCheck.cs

@@ -3,10 +3,10 @@ using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
 {
-    public class CDCheck : IPortableExecutableCheck
+    public class CDCheck : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/CDDVDCops.cs

@@ -63,7 +63,7 @@ namespace BinaryObjectScanner.Protection
     /// List of applications that have CD/DVD/WEB-Cops relating to a Windows update: https://www.betaarchive.com/wiki/index.php/Microsoft_KB_Archive/924867
     /// </summary>
 
-    public class CDDVDCops : IContentCheck, INewExecutableCheck, IPathCheck, IPortableExecutableCheck
+    public class CDDVDCops : IContentCheck, IExecutableCheck<NewExecutable>, IExecutableCheck<PortableExecutable>, IPathCheck
     {
         // TODO: Investigate reference to "CD32COPS.DLL" in "WETFLIPP.QZ_" in IA item "Triada_Russian_DVD_Complete_Collection_of_Erotic_Games".
         /// <inheritdoc/>
@@ -97,7 +97,7 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public string? CheckNewExecutable(string file, NewExecutable nex, bool includeDebug)
+        public string? CheckExecutable(string file, NewExecutable nex, bool includeDebug)
         {
             // TODO: Don't read entire file
             var data = nex.ReadArbitraryRange();
@@ -141,7 +141,7 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -228,13 +228,10 @@ namespace BinaryObjectScanner.Protection
             if (fileContent == null)
                 return null;
 
-#if NET20 || NET35 || NET40
             byte[] versionBytes = new byte[4];
             Array.Copy(fileContent, positions[0] + 15, versionBytes, 0, 4);
-            char[] version = versionBytes.Select(b => (char)b).ToArray();
-#else
-            char[] version = new ArraySegment<byte>(fileContent, positions[0] + 15, 4).Select(b => (char)b).ToArray();
-#endif
+            char[] version = Array.ConvertAll(versionBytes, b => (char)b);
+
             if (version[0] == 0x00)
                 return string.Empty;
 

BinaryObjectScanner/Protection/CDGuard.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
 using SabreTools.Matching.Paths;
@@ -21,10 +20,10 @@ namespace BinaryObjectScanner.Protection
     /// https://gamecopyworld.com/games/pc_omikron.shtml
     /// https://forum.ixbt.com/topic.cgi?id=31:3985
     /// </summary>
-    public class CDGuard : IPathCheck, IPortableExecutableCheck
+    public class CDGuard : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -46,7 +45,7 @@ namespace BinaryObjectScanner.Protection
             if (pex.Model.ImportTable?.ImportDirectoryTable != null)
             {
                 // Found in "Randevu.exe" in Redump entry 97142.
-                bool match = pex.Model.ImportTable.ImportDirectoryTable.Any(idte => idte?.Name != null && idte.Name.Equals("cdguard.dll", StringComparison.OrdinalIgnoreCase));
+                bool match = Array.Exists(pex.Model.ImportTable.ImportDirectoryTable, idte => idte?.Name != null && idte.Name.Equals("cdguard.dll", StringComparison.OrdinalIgnoreCase));
                 if (match)
                       return "CD-Guard Copy Protection System";
             }

BinaryObjectScanner/Protection/CDKey.cs

@@ -4,10 +4,10 @@ using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
 {
-    public class CDKey : IPortableExecutableCheck
+    public class CDKey : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/CDLock.cs

@@ -25,10 +25,10 @@ namespace BinaryObjectScanner.Protection
     /// Possible false positives include Redump entries 51241, 51373, 54397, 76437.
     /// Confirmed to be present on Redump entries 24287, 31615, 34448, 35967, 36627, 37700, 37788, 43221, 55788, and 66749.
     /// </summary>
-    public class CDLock : IPathCheck, IPortableExecutableCheck
+    public class CDLock : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/CDSHiELDSE.cs

@@ -1,13 +1,12 @@
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
 {
-    public class CDSHiELDSE : IPortableExecutableCheck
+    public class CDSHiELDSE : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -27,7 +26,7 @@ namespace BinaryObjectScanner.Protection
             var strs = pex.GetFirstSectionStrings("code") ?? pex.GetFirstSectionStrings("CODE");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("~0017.tmp")))
+                if (strs.Exists(s => s.Contains("~0017.tmp")))
                     return "CDSHiELD SE";
             }
 

BinaryObjectScanner/Protection/CactusDataShield.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
 using SabreTools.Matching.Content;
@@ -18,14 +17,13 @@ namespace BinaryObjectScanner.Protection
                 var contentMatchSets = new List<ContentMatchSet>
                 {
                     // CDSPlayer
-                    new(new byte?[] { 0x43, 0x44, 0x53, 0x50, 0x6C, 0x61, 0x79, 0x65, 0x72 }, "Cactus Data Shield 200"),
+                    new([0x43, 0x44, 0x53, 0x50, 0x6C, 0x61, 0x79, 0x65, 0x72], "Cactus Data Shield 200"),
 
                     // yucca.cds
-                    new(new byte?[] { 0x79, 0x75, 0x63, 0x63, 0x61, 0x2E, 0x63, 0x64, 0x73 }, "Cactus Data Shield 200"),
+                    new([0x79, 0x75, 0x63, 0x63, 0x61, 0x2E, 0x63, 0x64, 0x73], "Cactus Data Shield 200"),
                 };
 
-                if (contentMatchSets != null && contentMatchSets.Any())
-                    return MatchUtil.GetFirstMatch(file, fileContent, contentMatchSets, includeDebug);
+                return MatchUtil.GetFirstMatch(file, fileContent, contentMatchSets, includeDebug);
             }
 
             return null;

BinaryObjectScanner/Protection/CenegaProtectDVD.cs

@@ -12,10 +12,10 @@ namespace BinaryObjectScanner.Protection
     /// Games using this protection aren't able to be run from an ISO file, and presumably use DPM as a protection feature.
     /// <see href="https://github.com/TheRogueArchivist/DRML/blob/main/entries/Cenega_ProtectDVD/Cenega_ProtectDVD.md"/>
     /// </summary>
-    public class CengaProtectDVD : IPathCheck, IPortableExecutableCheck
+    public class CengaProtectDVD : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/Channelware.cs

@@ -20,10 +20,10 @@ namespace BinaryObjectScanner.Protection
     /// Add version detection. Redump entry 116358 is version 1.x and Redump entry 12354 is 2.x, but the file versions are inconsistent. 
     /// Investigate "NetActive Reach", which is is either a newer version of this DRM, or a new DRM created by the same company. (https://web.archive.org/web/20040101162921/http://www.netactive.com/Products/)
     /// </summary>
-    public class Channelware : IPathCheck, IPortableExecutableCheck
+    public class Channelware : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/ChosenBytesCodeLock.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
 using SabreTools.Matching.Paths;
@@ -20,10 +19,10 @@ namespace BinaryObjectScanner.Protection
     /// Code-Lock FAQ: https://web.archive.org/web/20041205165232/http://www.chosenbytes.com/codefaq.php
     /// Download (Version 2.35 trial): https://web.archive.org/web/20060220121200/http://www.chosenbytes.com:80/Code-Lock_cnet.zip
     /// </summary>
-    public class ChosenBytesCodeLock : IPathCheck, IPortableExecutableCheck
+    public class ChosenBytesCodeLock : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -40,13 +39,13 @@ namespace BinaryObjectScanner.Protection
             var strs = pex.GetFirstSectionStrings(".text");
             if (strs != null)
             {
-                if (strs.Any(s => s.Contains("CODE-LOCK.OCX")))
+                if (strs.Exists(s => s.Contains("CODE-LOCK.OCX")))
                     return "ChosenBytes Code-Lock";
 
-                if (strs.Any(s => s.Contains("Code-Lock.ocx")))
+                if (strs.Exists(s => s.Contains("Code-Lock.ocx")))
                     return "ChosenBytes Code-Lock";
 
-                if (strs.Any(s => s.Contains("CodeLock.Secure")))
+                if (strs.Exists(s => s.Contains("CodeLock.Secure")))
                     return "ChosenBytes Code-Lock";
             }
 

BinaryObjectScanner/Protection/CopyKiller.cs

@@ -15,10 +15,10 @@ namespace BinaryObjectScanner.Protection
     /// TODO: Add support for the developer's EXE obfuscator, "EXEShield Deluxe". Most, if not all, EXEShield protected files are currently detected as "EXE Stealth" by BOS.
     /// Samples include CopyKiller (Versions 3.64 & 3.99a) and SafeDiscScanner (Version 0.16) (https://archive.org/details/safediscscanner-0.16-webstylerzone-from-unofficial-source).
     /// </summary>
-    public class CopyKiller : IPathCheck, IPortableExecutableCheck
+    public class CopyKiller : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // TODO: Figure out how to differentiate between V3.99 and V3.99a.
             // Get the sections from the executable, if possible

BinaryObjectScanner/Protection/CopyLok.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using System;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -20,10 +20,10 @@ namespace BinaryObjectScanner.Protection
     /// 
     /// COPYLOK trademark: https://www.trademarkelite.com/europe/trademark/trademark-detail/000618512/COPYLOK.
     /// </summary>
-    public class CopyLok : IPortableExecutableCheck
+    public class CopyLok : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -33,7 +33,7 @@ namespace BinaryObjectScanner.Protection
             // If there are more than 2 icd-prefixed sections, then we have a match
             // Though this is the same name that SafeDisc uses for protected executables, this seems to be a coincidence.
             // Found in Redump entries 31557, 31674, 31675, 31708, 38239, 44210, and 53929.
-            int icdSectionCount = pex.SectionNames?.Count(s => s.StartsWith("icd")) ?? 0;
+            int icdSectionCount = Array.FindAll(pex.SectionNames ?? [], s => s.StartsWith("icd")).Length;
             if (icdSectionCount >= 2)
                 return "CopyLok / CodeLok";
 

BinaryObjectScanner/Protection/CopyX.cs

@@ -14,7 +14,7 @@ namespace BinaryObjectScanner.Protection
     // TODO: Technically not necessary, but just check for light/pro first and only if it isn't found look for the other.
     // It should be an Or situation and not an And situation.
     // TODO: Figure out if Light and Professional are what designate rings and rings+disccheck
-    public class CopyX : IPathCheck, IPortableExecutableCheck
+    public class CopyX : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         // Previous check 'Tivola Ring Protect' removed because it was found to actually be copy-x. 
         // The checks were for ZDAT/webmast.dxx and ZDAT/webmast.dxx, for Redump IDs 81628 and 116418.   
@@ -58,7 +58,7 @@ namespace BinaryObjectScanner.Protection
         // Find a viable way to check the last directory alphabetically and not just ZDAT*
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Checks for Professional
             // PEX checks intentionally only detect Professional
@@ -77,7 +77,7 @@ namespace BinaryObjectScanner.Protection
                 // TODO: This might need to check every single section. Unsure until more samples are acquired.
                 // TODO: TKKG also has an NE 3.1x executable with a reference. This can be added later.
                 // Samples: Redump ID 108150
-                if (pex.OverlayStrings.Any(s => s.Contains("optgraph.dll")))
+                if (pex.OverlayStrings.Exists(s => s.Contains("optgraph.dll")))
                     return "copy-X [Check disc for physical ring]";
             }
 
@@ -85,7 +85,7 @@ namespace BinaryObjectScanner.Protection
             if (strs != null)
             {
                 // Samples: Redump ID 82475, German Emergency 2 Deluxe, Redump ID 48393
-                if (strs.Any(s => s.Contains("optgraph.dll")))
+                if (strs.Exists(s => s.Contains("optgraph.dll")))
                     return "copy-X [Check disc for physical ring]";
             }
 

BinaryObjectScanner/Protection/CrypKey.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
 using SabreTools.Matching.Paths;
@@ -11,10 +10,10 @@ namespace BinaryObjectScanner.Protection
     // https://github.com/horsicq/Detect-It-Easy/blob/master/db/PE/CrypKey%20Installer.1.sg
     // https://github.com/horsicq/Detect-It-Easy/blob/master/db/PE/CrypKey.2.sg
     // https://github.com/wolfram77web/app-peid/blob/master/userdb.txt
-    public class CrypKey : IPathCheck, IPortableExecutableCheck
+    public class CrypKey : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;
@@ -29,15 +28,15 @@ namespace BinaryObjectScanner.Protection
                 // Full string:
                 // *CrypKey Instant 2.0 security i(32 - bit)  *
                 // *Copyright(c) 1996 Kenonic Controls Ltd.  *
-                if (strs.Any(s => s.Contains("CrypKey Instant 2.0 security")))
+                if (strs.Exists(s => s.Contains("CrypKey Instant 2.0 security")))
                     return "CrypKey Instant 2.0";
 
                 // Generic check to catch unknown CrypKey Instant versions.
-                if (strs.Any(s => s.Contains("CrypKey Instant")))
+                if (strs.Exists(s => s.Contains("CrypKey Instant")))
                     return "CrypKey Instant (Unknown version - Please report to us on GitHub)";
 
                 // Generic check to catch unknown CrypKey products.
-                if (strs.Any(s => s.Contains("CrypKey")))
+                if (strs.Exists(s => s.Contains("CrypKey")))
                     return "CrypKey (Unknown version - Please report to us on GitHub)";
             }
 

BinaryObjectScanner/Protection/Cucko.cs

@@ -10,10 +10,10 @@ namespace BinaryObjectScanner.Protection
     //      - Reference to `EASTL` and `EAStdC` are standard for EA products and does not indicate Cucko by itself
     //      - There's little information outside of PiD detection that actually knows about Cucko
     //      - Cucko is confirmed to, at least, use DMI checks.
-    public class Cucko : IPortableExecutableCheck
+    public class Cucko : IExecutableCheck<PortableExecutable>
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/Denuvo.cs

@@ -25,13 +25,13 @@ namespace BinaryObjectScanner.Protection
     /// https://www.wired.com/story/empress-drm-cracking-denuvo-video-game-piracy/
     /// </summary>
 
-    public class Denuvo : IPathCheck, IPortableExecutableCheck
+    public class Denuvo : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         // TODO: Investigate possible filename checks for Denuvo Anti-Tamper.
         // https://www.pcgamingwiki.com/wiki/Denuvo#Redeem.exe
 
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;

BinaryObjectScanner/Protection/DigiGuard.cs

@@ -23,10 +23,10 @@ namespace BinaryObjectScanner.Protection
     /// News article regarding GLFC and Accolade Games: https://www.gamespot.com/articles/accolade-games-on-dvd/1100-2460436/
     /// eBay listing for the "BIGWIG SOFTWARE LOCKER", which very likely contains DigiGuard: https://www.ebay.com/itm/325573968970
     /// </summary>
-    public class DigiGuard : IPathCheck, IPortableExecutableCheck
+    public class DigiGuard : IExecutableCheck<PortableExecutable>, IPathCheck
     {
         /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
         {
             // Get the sections from the executable, if possible
             var sections = pex.Model.SectionTable;