Fix linux publish script

Compensate for some additional variance in directory names found from new samples, in lieu of a more "advanced" check

.github/workflows/build_nupkg.yml

@@ -0,0 +1,43 @@
+name: Nuget Pack
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
+        
+    - name: Restore dependencies
+      run: dotnet restore
+      
+    - name: Pack
+      run: dotnet pack
+
+    - name: Upload build
+      uses: actions/upload-artifact@v4
+      with:
+        name: 'Nuget Package'
+        path: 'BinaryObjectScanner/bin/Release/*.nupkg'
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: 'BinaryObjectScanner/bin/Release/*.nupkg'
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True

.github/workflows/build_programs.yml

@@ -0,0 +1,55 @@
+name: Build Programs
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        project: [ExtractionTool, ProtectionScan]
+        runtime: [win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64]
+        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
+      with:
+        submodules: recursive
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        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') || startsWith(matrix.framework, 'net9')) && '-p:PublishSingleFile=true' || ''}}
+        
+    - name: Archive build
+      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
+      with:
+        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_${{ matrix.conf }}
+        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_${{ matrix.conf }}.zip
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_${{ matrix.conf }}.zip
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True

.github/workflows/check_pr.yml

@@ -0,0 +1,17 @@
+name: Build PR
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
+      
+    - name: Build
+      run: dotnet build

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "BinaryObjectScanner/_EXTERNAL/stormlibsharp"]
 	path = BinaryObjectScanner/_EXTERNAL/stormlibsharp
 	url = https://github.com/robpaveza/stormlibsharp.git
+[submodule "BinaryObjectScanner/_EXTERNAL/libmspack4n"]
+	path = BinaryObjectScanner/_EXTERNAL/libmspack4n
+	url = https://github.com/activescott/libmspack4n.git
+[submodule "BinaryObjectScanner/_EXTERNAL/LessIO"]
+	path = BinaryObjectScanner/_EXTERNAL/LessIO
+	url = https://github.com/activescott/LessIO.git

.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/net6.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
@@ -12,26 +10,34 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		Developer Guide.md = Developer Guide.md
 		LICENSE = LICENSE
 		publish-nix.sh = publish-nix.sh
-		publish-win.bat = publish-win.bat
+		publish-win.ps1 = publish-win.ps1
 		README.md = README.md
 	EndProjectSection
 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,82 +1,111 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <!-- Assembly Properties -->
-    <TargetFrameworks>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;osx-arm64</RuntimeIdentifiers>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>latest</LangVersion>
-    <Nullable>enable</Nullable>
-    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <!-- <TreatWarningsAsErrors>true</TreatWarningsAsErrors> --> <!-- Can't be enabled because of external code -->
-    <Version>3.0.1</Version>
-  
-    <!-- Package Properties -->
-    <Authors>Matt Nadareski</Authors>
-    <Description>Protection scanning library</Description>
-    <Copyright>Copyright (c)2018-2023 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>
 
-  <!-- Exclude certain parts of external modules for .NET Framework 4.5.2 and above -->
-  <PropertyGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-    <DefaultItemExcludes>
-      $(DefaultItemExcludes);
-      **\AssemblyInfo.cs;
-      _EXTERNAL\stormlibsharp\lib\**;
-      _EXTERNAL\stormlibsharp\src\TestConsole\**
-    </DefaultItemExcludes>
-  </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 all external modules for .NET Framework 4.0, .NET Core and modern .NET -->
-  <PropertyGroup Condition="!$(TargetFramework.StartsWith(`net4`)) OR $(TargetFramework.StartsWith(`net40`))">
-    <DefaultItemExcludes>
-      $(DefaultItemExcludes);
-      _EXTERNAL\**;
-    </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>
 
-  <!-- These are needed for dealing with native Windows DLLs -->
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-    <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>
+    <!-- Set a build flag for Windows specifically -->
+    <PropertyGroup Condition="'$(RuntimeIdentifier)'=='win-x86'">
+        <DefineConstants>$(DefineConstants);WIN</DefineConstants>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="OpenMcdf" Version="2.3.0" />
-    <PackageReference Include="SabreTools.Compression" Version="0.2.0" />
-    <PackageReference Include="SabreTools.IO" Version="1.2.0" />
-    <PackageReference Include="SabreTools.Matching" Version="1.2.0" />
-    <PackageReference Include="SabreTools.Models" Version="1.2.0" />
-    <PackageReference Include="SabreTools.Serialization" Version="1.2.1" />
-    <PackageReference Include="UnshieldSharp" Version="1.7.0" />
-    <PackageReference Include="WiseUnpacker" Version="1.2.0" />
-  </ItemGroup>
+    <!-- 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>
 
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net40`))">
-    <PackageReference Include="Microsoft.Bcl" Version="1.1.10" />
-  </ItemGroup>
+    <!-- Exclude all StormLibSharp for .NET Framework 4.0 -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net40`))">
+        <DefaultItemExcludes>
+            $(DefaultItemExcludes);
+            _EXTERNAL\stormlibsharp\src\**
+        </DefaultItemExcludes>
+    </PropertyGroup>
 
-  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
-    <PackageReference Include="SharpCompress" Version="0.34.1" />
-    <PackageReference Include="SharpZipLib" Version="1.4.2" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="7.0.0" />
-  </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 Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-    <PackageReference Include="System.Memory" Version="4.5.5" />
-  </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/CheckDictionary.cs

@@ -0,0 +1,26 @@
+namespace BinaryObjectScanner
+{
+    /// <summary>
+    /// Represents a mapping from checker to detected protection
+    /// </summary>
+#if NET20 || NET35
+    public class CheckDictionary<T> : System.Collections.Generic.Dictionary<T, string> where T : notnull
+#else
+    public class CheckDictionary<T> : System.Collections.Concurrent.ConcurrentDictionary<T, string> where T : notnull
+#endif
+    {
+        /// <inheritdoc cref="System.Collections.Generic.Dictionary{TKey, TValue}.Add(TKey, TValue)"/>
+        /// <remarks>Handles the proper Add implementation</remarks>
+        public void Append(T key, string? value)
+        {
+            if (value == null)
+                return;
+
+#if NET20 || NET35
+            this[key] = value;
+#else
+            TryAdd(key, value);
+#endif
+        }
+    }
+}

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/EnumerableExtensions.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+namespace BinaryObjectScanner
+{
+    internal static class EnumerableExtensions
+    {
+        /// <summary>
+        /// Wrap iterating through an enumerable with an action
+        /// </summary>
+        /// <remarks>
+        /// .NET Frameworks 2.0 and 3.5 process in series.
+        /// .NET Frameworks 4.0 onward process in parallel.
+        /// </remarks>
+        public static void IterateWithAction<T>(this IEnumerable<T> source, Action<T> action)
+        {
+#if NET20 || NET35
+            foreach (var item in source)
+            {
+                action(item);
+            }
+#else
+            System.Threading.Tasks.Parallel.ForEach(source, action);
+#endif
+        }
+    }
+}

BinaryObjectScanner/Factory.cs

@@ -1,5 +1,5 @@
 using BinaryObjectScanner.Interfaces;
-using BinaryObjectScanner.Utilities;
+using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner
 {
@@ -8,63 +8,65 @@ namespace BinaryObjectScanner
         /// <summary>
         /// Create an instance of a detectable based on file type
         /// </summary>
-        public static IDetectable? CreateDetectable(SupportedFileType fileType)
+        public static IDetectable? CreateDetectable(WrapperType fileType)
         {
-            switch (fileType)
+            return fileType switch
             {
-                case SupportedFileType.AACSMediaKeyBlock: return new FileType.AACSMediaKeyBlock();
-                case SupportedFileType.BDPlusSVM: return new FileType.BDPlusSVM();
-                //case SupportedFileType.CIA: return new FileType.CIA();
-                case SupportedFileType.Executable: return new FileType.Executable();
-                case SupportedFileType.LDSCRYPT: return new FileType.LDSCRYPT();
-                //case SupportedFileType.N3DS: return new FileType.N3DS();
-                //case SupportedFileType.Nitro: return new FileType.Nitro();
-                case SupportedFileType.PLJ: return new FileType.PLJ();
-                case SupportedFileType.SFFS: return new FileType.SFFS();
-                case SupportedFileType.Textfile: return new FileType.Textfile();
-                default: return null;
-            }
+                WrapperType.AACSMediaKeyBlock => new FileType.AACSMediaKeyBlock(),
+                WrapperType.BDPlusSVM => new FileType.BDPlusSVM(),
+                //WrapperType.CIA => new FileType.CIA(),
+                WrapperType.Executable => new FileType.Executable(),
+                WrapperType.LDSCRYPT => new FileType.LDSCRYPT(),
+                //WrapperType.N3DS => new FileType.N3DS(),
+                //WrapperType.Nitro => new FileType.Nitro(),
+                WrapperType.PlayJAudioFile => new FileType.PLJ(),
+                WrapperType.RealArcadeInstaller => new FileType.RealArcadeInstaller(),
+                WrapperType.RealArcadeMezzanine => new FileType.RealArcadeMezzanine(),
+                WrapperType.SFFS => new FileType.SFFS(),
+                WrapperType.Textfile => new FileType.Textfile(),
+                _ => null,
+            };
         }
 
         /// <summary>
         /// Create an instance of an extractable based on file type
         /// </summary>
-        public static IExtractable? CreateExtractable(SupportedFileType fileType)
+        public static IExtractable? CreateExtractable(WrapperType fileType)
         {
-            switch (fileType)
+            return fileType switch
             {
-                case SupportedFileType.BFPK: return new FileType.BFPK();
-                case SupportedFileType.BSP: return new FileType.BSP();
-                case SupportedFileType.BZip2: return new FileType.BZip2();
-                case SupportedFileType.CFB: return new FileType.CFB();
-                //case SupportedFileType.CIA: return new FileType.CIA();
-                case SupportedFileType.GCF: return new FileType.GCF();
-                case SupportedFileType.GZIP: return new FileType.GZIP();
-                case SupportedFileType.InstallShieldArchiveV3: return new FileType.InstallShieldArchiveV3();
-                case SupportedFileType.InstallShieldCAB: return new FileType.InstallShieldCAB();
-                case SupportedFileType.MicrosoftCAB: return new FileType.MicrosoftCAB();
-                case SupportedFileType.MicrosoftLZ: return new FileType.MicrosoftLZ();
-                case SupportedFileType.MPQ: return new FileType.MPQ();
-                //case SupportedFileType.N3DS: return new FileType.N3DS();
-                //case SupportedFileType.NCF: return new FileType.NCF();
-                //case SupportedFileType.Nitro: return new FileType.Nitro();
-                case SupportedFileType.PAK: return new FileType.PAK();
-                case SupportedFileType.PFF: return new FileType.PFF();
-                case SupportedFileType.PKZIP: return new FileType.PKZIP();
-                //case SupportedFileType.PLJ: return new FileType.PLJ();
-                //case SupportedFileType.Quantum: return new FileType.Quantum();
-                case SupportedFileType.RAR: return new FileType.RAR();
-                case SupportedFileType.SevenZip: return new FileType.SevenZip();
-                case SupportedFileType.SFFS: return new FileType.SFFS();
-                case SupportedFileType.SGA: return new FileType.SGA();
-                case SupportedFileType.TapeArchive: return new FileType.TapeArchive();
-                case SupportedFileType.VBSP: return new FileType.VBSP();
-                case SupportedFileType.VPK: return new FileType.VPK();
-                case SupportedFileType.WAD: return new FileType.WAD();
-                case SupportedFileType.XZ: return new FileType.XZ();
-                case SupportedFileType.XZP: return new FileType.XZP();
-                default: return null;
-            }
+                WrapperType.BFPK => new FileType.BFPK(),
+                WrapperType.BSP => new FileType.BSP(),
+                WrapperType.BZip2 => new FileType.BZip2(),
+                WrapperType.CFB => new FileType.CFB(),
+                //WrapperType.CIA => new FileType.CIA(),
+                WrapperType.GCF => new FileType.GCF(),
+                WrapperType.GZIP => new FileType.GZIP(),
+                WrapperType.InstallShieldArchiveV3 => new FileType.InstallShieldArchiveV3(),
+                WrapperType.InstallShieldCAB => new FileType.InstallShieldCAB(),
+                WrapperType.MicrosoftCAB => new FileType.MicrosoftCAB(),
+                WrapperType.MicrosoftLZ => new FileType.MicrosoftLZ(),
+                WrapperType.MoPaQ => new FileType.MPQ(),
+                //WrapperType.N3DS => new FileType.N3DS(),
+                //WrapperType.NCF => new FileType.NCF(),
+                //WrapperType.Nitro => new FileType.Nitro(),
+                WrapperType.PAK => new FileType.PAK(),
+                WrapperType.PFF => new FileType.PFF(),
+                WrapperType.PKZIP => new FileType.PKZIP(),
+                //WrapperType.PlayJAudioFile => new FileType.PLJ(),
+                //WrapperType.Quantum => new FileType.Quantum(),
+                WrapperType.RAR => new FileType.RAR(),
+                WrapperType.SevenZip => new FileType.SevenZip(),
+                WrapperType.SFFS => new FileType.SFFS(),
+                WrapperType.SGA => new FileType.SGA(),
+                WrapperType.TapeArchive => new FileType.TapeArchive(),
+                WrapperType.VBSP => new FileType.VBSP(),
+                WrapperType.VPK => new FileType.VPK(),
+                WrapperType.WAD => new FileType.WAD(),
+                WrapperType.XZ => new FileType.XZ(),
+                WrapperType.XZP => new FileType.XZP(),
+                _ => null,
+            };
         }
     }
 }

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.Read))
-            {
-                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.Read))
-            {
-                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

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 #endif
@@ -14,40 +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.Read))
-            {
-                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 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;
             }
         }
 
@@ -111,19 +106,19 @@ namespace BinaryObjectScanner.FileType
 
                 // Create the output path
                 string filePath = Path.Combine(outputDirectory, file.Name ?? $"file{index}");
-                using (FileStream fs = File.OpenWrite(filePath))
-                {
-                    // Read the data block
-                    var data = item.ReadFromDataSource(offset, compressedSize);
-                    if (data == null)
-                        return false;
+                using FileStream fs = File.OpenWrite(filePath);
 
-                    // If we have uncompressed data
-                    if (compressedSize == file.UncompressedSize)
-                    {
-                        fs.Write(data, 0, compressedSize);
-                    }
-#if NET462_OR_GREATER
+                // Read the data block
+                var data = item.ReadFromDataSource(offset, compressedSize);
+                if (data == null)
+                    return false;
+
+                // If we have uncompressed data
+                if (compressedSize == file.UncompressedSize)
+                {
+                    fs.Write(data, 0, compressedSize);
+                }
+#if NET462_OR_GREATER || NETCOREAPP
                     else
                     {
                         MemoryStream ms = new MemoryStream(data);
@@ -131,7 +126,6 @@ namespace BinaryObjectScanner.FileType
                         zs.CopyTo(fs);
                     }
 #endif
-                }
 
                 return true;
             }

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.Read))
-            {
-                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;
             }
         }
 
@@ -109,7 +104,7 @@ namespace BinaryObjectScanner.FileType
             }
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path
@@ -188,7 +183,7 @@ namespace BinaryObjectScanner.FileType
             string filename = $"{texture.Name}.bmp";
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

BinaryObjectScanner/FileType/BZip2.cs

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
 #endif
@@ -14,48 +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.Read))
-            {
-                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)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
-#if NET462_OR_GREATER
+#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

@@ -2,7 +2,9 @@
 using System.IO;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
+#if NET40_OR_GREATER || NETCOREAPP
 using OpenMcdf;
+#endif
 
 namespace BinaryObjectScanner.FileType
 {
@@ -12,78 +14,77 @@ 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.Read))
-            {
-                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)
         {
+#if NET20 || NET35
+            // Not supported for .NET Framework 2.0 or .NET Framework 3.5 due to library support
+            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
         }
 
         /// <remarks>Adapted from LibMSI</remarks>

BinaryObjectScanner/FileType/Executable.cs

@@ -1,13 +1,11 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
+using BinaryObjectScanner.Data;
 using BinaryObjectScanner.Interfaces;
-using BinaryObjectScanner.Utilities;
+using SabreTools.IO.Extensions;
+using SabreTools.Serialization.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.FileType
@@ -15,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
@@ -33,105 +27,6 @@ namespace BinaryObjectScanner.FileType
         /// </summary>
         public bool IncludePackers { get; set; }
 
-        /// <summary>
-        /// Cache for all IContentCheck types
-        /// </summary>
-        public static IEnumerable<IContentCheck> ContentCheckClasses
-        {
-            get
-            {
-                if (contentCheckClasses == null)
-                    contentCheckClasses = InitCheckClasses<IContentCheck>();
-
-                return contentCheckClasses ?? Enumerable.Empty<IContentCheck>();
-            }
-        }
-
-        /// <summary>
-        /// Cache for all ILinearExecutableCheck types
-        /// </summary>
-        public static IEnumerable<ILinearExecutableCheck> LinearExecutableCheckClasses
-        {
-            get
-            {
-                if (linearExecutableCheckClasses == null)
-                    linearExecutableCheckClasses = InitCheckClasses<ILinearExecutableCheck>();
-
-                return linearExecutableCheckClasses ?? Enumerable.Empty<ILinearExecutableCheck>();
-            }
-        }
-
-        /// <summary>
-        /// Cache for all IMSDOSExecutableCheck types
-        /// </summary>
-        public static IEnumerable<IMSDOSExecutableCheck> MSDOSExecutableCheckClasses
-        {
-            get
-            {
-                if (msdosExecutableCheckClasses == null)
-                    msdosExecutableCheckClasses = InitCheckClasses<IMSDOSExecutableCheck>();
-
-                return msdosExecutableCheckClasses ?? Enumerable.Empty<IMSDOSExecutableCheck>();
-            }
-        }
-
-        /// <summary>
-        /// Cache for all INewExecutableCheck types
-        /// </summary>
-        public static IEnumerable<INewExecutableCheck> NewExecutableCheckClasses
-        {
-            get
-            {
-                if (newExecutableCheckClasses == null)
-                    newExecutableCheckClasses = InitCheckClasses<INewExecutableCheck>();
-
-                return newExecutableCheckClasses ?? Enumerable.Empty<INewExecutableCheck>();
-            }
-        }
-
-        /// <summary>
-        /// Cache for all IPortableExecutableCheck types
-        /// </summary>
-        public static IEnumerable<IPortableExecutableCheck> PortableExecutableCheckClasses
-        {
-            get
-            {
-                if (portableExecutableCheckClasses == null)
-                    portableExecutableCheckClasses = InitCheckClasses<IPortableExecutableCheck>();
-
-                return portableExecutableCheckClasses ?? Enumerable.Empty<IPortableExecutableCheck>();
-            }
-        }
-
-        #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/>
@@ -140,57 +35,104 @@ namespace BinaryObjectScanner.FileType
             if (!File.Exists(file))
                 return null;
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <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 queue
-            var protections = new ConcurrentQueue<string>();
+            // Create the internal list
+            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.ToArray());
+                protections.Append(file, subProtections.Values);
             }
 
             if (wrapper is MSDOS mz)
             {
-                var subProtections = RunMSDOSExecutableChecks(file, stream, mz, includeDebug);
-                if (subProtections != null)
-                    protections.AddRange(subProtections.Values.ToArray());
+                // 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.ToArray());
+                // 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.ToArray());
+                // 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.ToArray());
+                // 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
@@ -201,45 +143,38 @@ 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 ConcurrentDictionary<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.IsNullOrWhiteSpace(file))
-                return null;
+            if (string.IsNullOrEmpty(file))
+                return protections;
             else if (!File.Exists(file))
-                return null;
+                return protections;
 
             // Read the file contents
-            byte[] fileContent = new byte[0];
+            byte[] fileContent = [];
             try
             {
-#if NET40
-                using (BinaryReader br = new BinaryReader(stream, Encoding.Default))
-#else
-                using (BinaryReader br = new BinaryReader(stream, Encoding.Default, true))
-#endif
-                {
-                    fileContent = br.ReadBytes((int)stream.Length);
-                    if (fileContent == null)
-                        return null;
-                }
+                fileContent = stream.ReadBytes((int)stream.Length);
+                if (fileContent == null)
+                    return protections;
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return protections;
             }
 
-            // Create the output dictionary
-            var protections = new ConcurrentDictionary<IContentCheck, string>();
-
             // Iterate through all checks
-            Parallel.ForEach(ContentCheckClasses, checkClass =>
+            StaticChecks.ContentCheckClasses.IterateWithAction(checkClass =>
             {
                 // Get the protection for the class, if possible
                 var protection = checkClass.CheckContents(file!, fileContent, includeDebug);
-                if (string.IsNullOrWhiteSpace(protection))
+                if (string.IsNullOrEmpty(protection))
                     return;
 
                 // If we are filtering on game engines
@@ -250,30 +185,34 @@ namespace BinaryObjectScanner.FileType
                 if (CheckIfPacker(checkClass) && !IncludePackers)
                     return;
 
-                protections.TryAdd(checkClass, protection!);
+                protections.Append(checkClass, protection);
             });
 
             return protections;
         }
 
         /// <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 ConcurrentDictionary<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 ConcurrentDictionary<ILinearExecutableCheck, string>();
+            var protections = new CheckDictionary<U>();
 
             // Iterate through all checks
-            Parallel.ForEach(LinearExecutableCheckClasses, checkClass =>
+            checks.IterateWithAction(checkClass =>
             {
                 // Get the protection for the class, if possible
-                var protection = checkClass.CheckLinearExecutable(file, lex, includeDebug);
-                if (string.IsNullOrWhiteSpace(protection))
+                var protection = checkClass.CheckExecutable(file, exe, includeDebug);
+                if (string.IsNullOrEmpty(protection))
                     return;
 
                 // If we are filtering on game engines
@@ -284,133 +223,102 @@ namespace BinaryObjectScanner.FileType
                 if (CheckIfPacker(checkClass) && !IncludePackers)
                     return;
 
-                protections.TryAdd(checkClass, protection!);
+                protections.Append(checkClass, protection);
             });
 
             return protections;
         }
 
         /// <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 ConcurrentDictionary<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 ConcurrentDictionary<IMSDOSExecutableCheck, string>();
+            var protections = new ProtectionDictionary();
 
-            // Iterate through all checks
-            Parallel.ForEach(MSDOSExecutableCheckClasses, 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.IsNullOrWhiteSpace(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.TryAdd(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 ConcurrentDictionary<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 ConcurrentDictionary<INewExecutableCheck, string>();
+            // If we have an invalid extractable somehow
+            if (impl == null)
+                return [];
 
-            // Iterate through all checks
-            Parallel.ForEach(NewExecutableCheckClasses, checkClass =>
+            // If the extractable file itself fails
+            try
             {
-                // Get the protection for the class, if possible
-                var protection = checkClass.CheckNewExecutable(file, nex, includeDebug);
-                if (string.IsNullOrWhiteSpace(protection))
-                    return;
+                // Extract and get the output path
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                bool extracted = impl.Extract(file, exe, tempPath, includeDebug);
 
-                // If we are filtering on game engines
-                if (CheckIfGameEngine(checkClass) && !IncludeGameEngines)
-                    return;
+                // Collect and format all found protections
+                ProtectionDictionary? subProtections = null;
+                if (extracted && getProtections != null)
+                    subProtections = getProtections(tempPath);
 
-                // If we are filtering on packers
-                if (CheckIfPacker(checkClass) && !IncludePackers)
-                    return;
+                // If temp directory cleanup fails
+                try
+                {
+                    if (Directory.Exists(tempPath))
+                        Directory.Delete(tempPath, true);
+                }
+                catch (Exception ex)
+                {
+                    if (includeDebug) Console.WriteLine(ex);
+                }
 
-                protections.TryAdd(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 ConcurrentDictionary<IPortableExecutableCheck, string> RunPortableExecutableChecks(string file, Stream stream, PortableExecutable pex, bool includeDebug)
-        {
-            // Create the output dictionary
-            var protections = new ConcurrentDictionary<IPortableExecutableCheck, string>();
-
-            // Iterate through all checks
-            Parallel.ForEach(PortableExecutableCheckClasses, checkClass =>
+                // Prepare the returned protections
+                subProtections?.StripFromKeys(tempPath);
+                subProtections?.PrependToKeys(file);
+                return subProtections ?? [];
+            }
+            catch (Exception ex)
             {
-                // Get the protection for the class, if possible
-                var protection = checkClass.CheckPortableExecutable(file, pex, includeDebug);
-                if (string.IsNullOrWhiteSpace(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.TryAdd(checkClass, protection!);
-            });
-
-            return protections;
-        }
-
-        #endregion
-
-        #region Initializers
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T>? InitCheckClasses<T>() =>
-            InitCheckClasses<T>(typeof(Handler).Assembly) ?? Enumerable.Empty<T>();
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T>? InitCheckClasses<T>(Assembly assembly)
-        {
-            return assembly.GetTypes()?
-                .Where(t => t.IsClass && t.GetInterface(typeof(T).Name) != null)?
-                .Select(t => (T?)Activator.CreateInstance(t))
-                .Cast<T>() ?? [];
+                if (includeDebug) Console.WriteLine(ex);
+                return [];
+            }
         }
 
         #endregion
@@ -423,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>
@@ -432,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.Read))
-            {
-                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;
             }
         }
 
@@ -116,7 +111,7 @@ namespace BinaryObjectScanner.FileType
             var filename = file.Path;
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

BinaryObjectScanner/FileType/GZIP.cs

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.GZip;
 #endif
@@ -14,59 +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.Read))
-            {
-                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)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
-#if NET462_OR_GREATER
+#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 we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        // If the entry has an invalid key
+                        if (entry.Key == null)
+                            continue;
+
+                        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,8 +1,7 @@
 using System;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
-using UnshieldSharp.Archive;
+using ISv3 = UnshieldSharp.Archive.InstallShieldArchiveV3;
 
 namespace BinaryObjectScanner.FileType
 {
@@ -12,38 +11,32 @@ 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.Read))
-            {
-                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);
-
-                UnshieldSharp.Archive.InstallShieldArchiveV3 archive = new UnshieldSharp.Archive.InstallShieldArchiveV3(file);
-                foreach (CompressedFile cfile in archive.Files.Select(kvp => kvp.Value))
+                var archive = new ISv3(file);
+                foreach (var cfile in archive.Files)
                 {
                     try
                     {
-                        string tempFile = Path.Combine(tempPath, cfile.FullPath!);
+                        string tempFile = Path.Combine(outDir, cfile.Key);
                         var directoryName = Path.GetDirectoryName(tempFile);
                         if (directoryName != null && !Directory.Exists(directoryName))
                             Directory.CreateDirectory(directoryName);
 
-                        (byte[]? fileContents, string? error) = archive.Extract(cfile.FullPath!);
-                        if (fileContents == null || !string.IsNullOrWhiteSpace(error))
+                        byte[]? fileContents = archive.Extract(cfile.Key, out string? error);
+                        if (fileContents == null || !string.IsNullOrEmpty(error))
                             continue;
 
                         using (FileStream fs = File.OpenWrite(tempFile))
@@ -57,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,19 +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.Read))
-            {
-                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)
         {
             // Get the name of the first cabinet file or header
             var directory = Path.GetDirectoryName(file);
@@ -52,35 +50,31 @@ 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 == null)
-                    return null;
+                if (cabfile?.HeaderList == null)
+                    return false;
 
-                for (int i = 0; i < cabfile.FileCount; i++)
+                for (int i = 0; i < cabfile.HeaderList.FileCount; i++)
                 {
                     try
                     {
                         // Check if the file is valid first
-                        if (!cabfile.FileIsValid(i))
+                        if (!cabfile.HeaderList.FileIsValid(i))
                             continue;
 
                         string tempFile;
                         try
                         {
-                            string? filename = cabfile.FileName(i);
-                            tempFile = Path.Combine(tempPath, filename ?? string.Empty);
+                            string? filename = cabfile.HeaderList.GetFileName(i);
+                            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);
@@ -91,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.Read))
-            {
-                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

@@ -1,7 +1,6 @@
-using System;
-using System.IO;
+using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NETFRAMEWORK && !NET40
+#if (NET452_OR_GREATER || NETCOREAPP) && WIN
 using StormLibSharp;
 #endif
 
@@ -13,72 +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.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            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 NET40 || NETCOREAPP || NET5_0_OR_GREATER
-            // Not supported for .NET Core and modern .NET due to Windows DLL requirements
-            return null;
+#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 false;
 #else
             try
             {
-                // Create a temp output directory
-                string tempPath = Path.Combine(Path.GetTempPath(), 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 (MpqArchive 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 (StreamReader 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 (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        if (includeDebug) System.Console.WriteLine(ex);
                     }
                 }
 
-                return tempPath;
+                return true;
             }
-            catch (Exception ex)
+            catch (System.Exception ex)
             {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
+                if (includeDebug) System.Console.WriteLine(ex);
+                return false;
             }
 #endif
         }

BinaryObjectScanner/FileType/MicrosoftCAB.cs

@@ -1,7 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using BinaryObjectScanner.Interfaces;
+#if (NET40_OR_GREATER || NETCOREAPP) && WIN
+using LibMSPackN;
+#endif
 
 namespace BinaryObjectScanner.FileType
 {
@@ -13,21 +14,52 @@ 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.Read))
-            {
-                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;
+#if NET20 || NET35 || !WIN
+            // Not supported for old .NET due to feature requirements
+            // Not supported in non-Windows builds due to DLL requirements
+            return false;
+#else
+            try
+            {
+                // Loop over each entry
+                var cabArchive = new MSCabinet(file);
+                foreach (var compressedFile in cabArchive.GetFiles())
+                {
+                    try
+                    {
+                        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 true;
+            }
+            catch (System.Exception ex)
+            {
+                if (includeDebug) System.Console.WriteLine(ex);
+                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.Read))
-            {
-                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.Read))
-            {
-                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;
             }
         }
 
@@ -98,7 +93,7 @@ namespace BinaryObjectScanner.FileType
             var filename = directoryItem.ItemName;
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

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.Read))
-            {
-                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

@@ -1,9 +1,10 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,62 +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.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, lookForHeader, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            if (stream == null)
-                return null;
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
+            => Extract(stream, file, outDir, lookForHeader: false, includeDebug);
 
-#if NET462_OR_GREATER
+        /// <inheritdoc cref="IExtractable.Extract(Stream?, string, string, bool)"/>
+        public bool Extract(Stream? stream, string file, string outDir, bool lookForHeader, bool includeDebug)
+        {
+            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 we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            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);
-                        }
+                        // 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;
+
+                        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.Read))
-            {
-                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.Read))
-            {
-                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;
             }
         }
 
@@ -129,7 +124,7 @@ namespace BinaryObjectScanner.FileType
             // string filename = fileDescriptor.FileName;
 
             // // If we have an invalid output directory
-            // if (string.IsNullOrWhiteSpace(outputDirectory))
+            // if (string.IsNullOrEmpty(outputDirectory))
             //     return false;
 
             // // Create the full output path

BinaryObjectScanner/FileType/RAR.cs

@@ -1,9 +1,10 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.Rar;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,59 +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.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Extract(fs, file, outDir, lookForHeader, includeDebug);
         }
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            if (stream == null)
-                return null;
+        public bool Extract(Stream? stream, string file, string outDir, bool includeDebug)
+            => Extract(stream, file, outDir, lookForHeader: false, includeDebug);
 
-#if NET462_OR_GREATER
+        /// <inheritdoc cref="IExtractable.Extract(Stream?, string, string, bool)"/>
+        public bool Extract(Stream? stream, string file, string outDir, bool lookForHeader, bool includeDebug)
+        {
+            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 we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        // 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(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

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Matching;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// RealArcade Installer. Known to use the ".rgs" file extension.
+    /// 
+    /// TODO: Add further parsing, game ID and name should be possible to parse.
+    /// </summary>
+    public class RealArcadeInstaller : IDetectable
+    {
+        /// <inheritdoc/>
+        public string? Detect(string file, bool includeDebug)
+        {
+            if (!File.Exists(file))
+                return null;
+
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
+        }
+
+        /// <inheritdoc/>
+        public string? Detect(Stream stream, string file, bool includeDebug)
+        {
+            try
+            {
+                byte[] magic = new byte[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)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+            }
+
+            return null;
+        }
+    }
+}

BinaryObjectScanner/FileType/RealArcadeMezzanine.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Matching;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// RealArcade Mezzanine files, which contain metadata. Known to use the ".mez" file extension.
+    /// 
+    /// TODO: Add further parsing, game ID should be possible to parse.
+    /// </summary>
+    public class RealArcadeMezzanine : IDetectable
+    {
+        /// <inheritdoc/>
+        public string? Detect(string file, bool includeDebug)
+        {
+            if (!File.Exists(file))
+                return null;
+
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
+        }
+
+        /// <inheritdoc/>
+        public string? Detect(Stream stream, string file, bool includeDebug)
+        {
+            try
+            {
+                byte[] magic = new byte[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)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+            }
+
+            return null;
+        }
+    }
+}

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.Read))
-            {
-                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.Read))
-            {
-                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,11 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
-using ICSharpCode.SharpZipLib.Zip.Compression;
-#endif
+using SabreTools.Compression.zlib;
 
 namespace BinaryObjectScanner.FileType
 {
@@ -15,40 +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.Read))
-            {
-                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 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;
             }
         }
 
@@ -59,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)
@@ -92,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)
@@ -112,102 +102,99 @@ 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?
 
             // Reverse and assemble the filename
             parentNames.Reverse();
-            filename = Path.Combine(parentNames.Cast<string>().ToArray());
+#if NET20 || NET35
+            filename = parentNames[0];
+            for (int i = 1; i < parentNames.Count; i++)
+            {
+                filename = Path.Combine(filename, parentNames[i]);
+            }
+#else
+            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
@@ -223,19 +210,30 @@ namespace BinaryObjectScanner.FileType
             }
             else
             {
-                // Decompress the data
-#if NET462_OR_GREATER
+                // Inflate the data into the buffer
+                var zstream = new ZLib.z_stream_s();
                 data = new byte[outputFileSize];
-                Inflater inflater = new Inflater();
-                inflater.SetInput(compressedData);
-                inflater.Inflate(data);
-#else
-                data = new byte[outputFileSize];
-#endif
+                unsafe
+                {
+                    fixed (byte* payloadPtr = compressedData)
+                    fixed (byte* dataPtr = data)
+                    {
+                        zstream.next_in = payloadPtr;
+                        zstream.avail_in = (uint)compressedData.Length;
+                        zstream.total_in = (uint)compressedData.Length;
+                        zstream.next_out = dataPtr;
+                        zstream.avail_out = (uint)data.Length;
+                        zstream.total_out = 0;
+
+                        ZLib.inflateInit_(zstream, ZLib.zlibVersion(), compressedData.Length);
+                        int zret = ZLib.inflate(zstream, 1);
+                        ZLib.inflateEnd(zstream);
+                    }
+                }
             }
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path
@@ -250,10 +248,8 @@ namespace BinaryObjectScanner.FileType
             try
             {
                 // Open the output file for writing
-                using (Stream fs = File.OpenWrite(filename))
-                {
-                    fs.Write(data, 0, data.Length);
-                }
+                using Stream fs = File.OpenWrite(filename);
+                fs.Write(data, 0, data.Length);
             }
             catch
             {

BinaryObjectScanner/FileType/SevenZip.cs

@@ -1,9 +1,10 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.SevenZip;
+using SharpCompress.Readers;
 #endif
 
 namespace BinaryObjectScanner.FileType
@@ -14,56 +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.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            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 NET462_OR_GREATER
+            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 we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        // 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(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

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Archives;
 using SharpCompress.Archives.Tar;
 #endif
@@ -14,59 +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.Read))
-            {
-                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)
         {
-            if (stream == null)
-                return null;
+            if (stream == null || !stream.CanRead)
+                return false;
 
-#if NET462_OR_GREATER
+#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 we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
+                        // If the entry is a directory
+                        if (entry.IsDirectory)
+                            continue;
 
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            entry.WriteToFile(tempFile);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
+                        // 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(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/Textfile.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.Read))
-            {
-                return Detect(fs, file, includeDebug);
-            }
+            using var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            return Detect(fs, file, includeDebug);
         }
 
         /// <inheritdoc/>
@@ -33,7 +31,7 @@ namespace BinaryObjectScanner.FileType
             {
                 // Load the current file content
                 var fileContent = string.Empty;
-#if NET40
+#if NET20 || NET35 || NET40
                 using (var sr = new StreamReader(stream, Encoding.Default, true, 1024 * 1024))
 #else
                 using (var sr = new StreamReader(stream, Encoding.Default, true, 1024 * 1024, true))
@@ -56,6 +54,28 @@ namespace BinaryObjectScanner.FileType
                 else if (fileContent.Contains("Please enter a valid registration number"))
                     protections.Add("CD-Key / Serial");
 
+                // Channelware
+                // Found in "README.TXT" in Redump entry 116358.
+                if (fileContent.Contains("This application is a Channelware-activated product."))
+                    protections.Add("Channelware");
+                // Found in "Swr.dat" in the "TOYSTORY" installation folder from Redump entry 12354.
+                if (fileContent.Contains("cwsw.com/authts"))
+                    protections.Add("Channelware");
+
+                // CopyKiller
+                // Found in "autorun.dat" in CopyKiller versions 3.62 and 3.64.
+                if (fileContent.Contains("CopyKiller CD-Protection V3.6x"))
+                    protections.Add("CopyKiller V3.62-V3.64");
+                // Found in "autorun.dat" in CopyKiller versions 3.99 and 3.99a.
+                else if (fileContent.Contains("CopyKiller V4 CD / DVD-Protection"))
+                    protections.Add("CopyKiller V3.99+");
+                // Found in "engine.wzc" in CopyKiller versions 3.62 and 3.64.
+                else if (fileContent.Contains("CopyKiller V3.6x Protection Engine"))
+                    protections.Add("CopyKiller V3.62-V3.64");
+                // Found in "engine.wzc" in CopyKiller versions 3.99 and 3.99a.
+                else if (fileContent.Contains("CopyKiller V3.99x Protection Engine"))
+                            protections.Add("CopyKiller V3.99+");
+
                 // Freelock
                 // Found in "FILE_ID.DIZ" distributed with Freelock.
                 if (fileContent.Contains("FREELOCK 1.0"))
@@ -88,18 +108,56 @@ namespace BinaryObjectScanner.FileType
                     protections.Add("MediaMax CD-3");
 
                 // phenoProtect
+                // Found in Redump entry 84082.
                 if (fileContent.Contains("phenoProtect"))
                     protections.Add("phenoProtect");
+                // Additional check to minimize overmatching.
+                if (fileContent.Contains("InstallSHIELD Software Coporation"))
+                    // Found in Redump entry 102493.
+                    if (fileContent.Contains("COPYPROTECTION_FAILEDR"))
+                        protections.Add("phenoProtect");
 
                 // Rainbow Sentinel
                 // Found in "SENTW95.HLP" and "SENTINEL.HLP" in BA entry "Autodesk AutoCAD LT 98 (1998) (CD) [English] [Dutch]".
                 if (fileContent.Contains("Rainbow Sentinel Driver Help"))
                     protections.Add("Rainbow Sentinel");
+                // Found in "\disc4\cad\sdcc_200.zip\DISK1\_USER1.HDR\Language_Independent_Intel_32_Files\SNTNLUSB.INF" in "CICA 32 For Windows CD-ROM (Walnut Creek) (October 1999) (Disc 4).iso" in IA item "CICA_32_For_Windows_CD-ROM_Walnut_Creek_October_1999".
+                if (fileContent.Contains("SNTNLUSB.SvcDesc=\"Rainbow Security Device\""))
+                    protections.Add("Rainbow Sentinel USB Driver");
+                if (fileContent.Contains("SntUsb95.SvcDesc=\"Rainbow Security Device\""))
+                    protections.Add("Rainbow Sentinel USB Driver");
 
                 // Found in "OEMSETUP.INF" in BA entry "Autodesk AutoCAD LT 98 (1998) (CD) [English] [Dutch]".
                 if (fileContent.Contains("Sentinel Driver Disk"))
                     protections.Add("Rainbow Sentinel");
 
+                // SafeCast
+                // Found in "AdlmLog.xml" in IA item game-programming-in-c-start-to-finish-2006 after installing "3dsMax8_Demo.zip".
+                if (fileContent.Contains("<NAME>SAFECAST</NAME>"))
+                    protections.Add("SafeCast");
+
+                // SafeDisc 
+                // TODO: Add better version parsing.
+                // Found in "Info.plist" in Redump entries 23983, 42762, 72713, 73070, and 89603.
+                if (fileContent.Contains("<string>com.europevisionmacro.SafeDiscDVD</string>"))
+                {
+                    if (fileContent.Contains("<string>2.90.032</string>"))
+                        protections.Add("SafeDiscDVD for Macintosh 2.90.032");
+                    else
+                        protections.Add("SafeDiscDVD for Macintosh (Unknown Version - Please report to us on GitHub)");
+                }
+
+                // Found in "Info.plist" in Redump entry 89649.
+                if (fileContent.Contains("<string>com.macrovisioneurope.SafeDiscLT</string>"))
+                {
+                    // TODO: Investigate why "CFBundleGetInfoString" and "CFBundleShortVersionString" say version 2.70.020, but "CFBundleVersion" says version 2.70.010.
+                    if (fileContent.Contains("<string>2.70.020</string"))
+                        protections.Add("SafeDiscLT for Macintosh 2.70.020");
+                    else
+                        protections.Add("SafeDiscLT for Macintosh (Unknown Version - Please report to us on GitHub)");
+                }
+
+
                 // The full line from a sample is as follows:
                 //
                 // The files securom_v7_01.dat and securom_v7_01.bak have been created during the installation of a SecuROM protected application.
@@ -123,7 +181,7 @@ namespace BinaryObjectScanner.FileType
                 if (includeDebug) Console.WriteLine(ex);
             }
 
-            return string.Join(";", protections);
+            return string.Join(";", [.. protections]);
         }
     }
 }

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.Read))
-            {
-                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;
             }
         }
 
@@ -107,7 +102,7 @@ namespace BinaryObjectScanner.FileType
             }
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

BinaryObjectScanner/FileType/VPK.cs

@@ -1,8 +1,7 @@
 using System;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
-using SabreTools.IO;
+using SabreTools.IO.Extensions;
 
 namespace BinaryObjectScanner.FileType
 {
@@ -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.Read))
-            {
-                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;
             }
         }
 
@@ -112,7 +106,7 @@ namespace BinaryObjectScanner.FileType
 
                 // Get the archive filename
                 string archiveFileName = item.ArchiveFilenames[directoryItem.DirectoryEntry.ArchiveIndex];
-                if (string.IsNullOrWhiteSpace(archiveFileName))
+                if (string.IsNullOrEmpty(archiveFileName))
                     return false;
 
                 // If the archive doesn't exist
@@ -124,7 +118,7 @@ namespace BinaryObjectScanner.FileType
                 try
                 {
                     // Open the archive
-                    archiveStream = File.OpenRead(archiveFileName);
+                    archiveStream = File.Open(archiveFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
 
                     // Seek to the data
                     archiveStream.Seek(directoryItem.DirectoryEntry.EntryOffset, SeekOrigin.Begin);
@@ -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
@@ -152,11 +146,11 @@ namespace BinaryObjectScanner.FileType
 
             // Create the filename
             string filename = $"{directoryItem.Name}.{directoryItem.Extension}";
-            if (!string.IsNullOrWhiteSpace(directoryItem.Path))
+            if (!string.IsNullOrEmpty(directoryItem.Path))
                 filename = Path.Combine(directoryItem.Path, filename);
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

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.Read))
-            {
-                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;
             }
         }
 
@@ -98,7 +93,7 @@ namespace BinaryObjectScanner.FileType
             string filename = $"{lump.Name}.lmp";
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

BinaryObjectScanner/FileType/XZ.cs

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
+#if NET462_OR_GREATER || NETCOREAPP
 using SharpCompress.Compressors.Xz;
 #endif
 
@@ -13,45 +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.Read))
-            {
-                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)
         {
-#if NET462_OR_GREATER
+#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.Read))
-            {
-                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;
 
@@ -108,7 +102,7 @@ namespace BinaryObjectScanner.FileType
             var filename = directoryItem.Name;
 
             // If we have an invalid output directory
-            if (string.IsNullOrWhiteSpace(outputDirectory))
+            if (string.IsNullOrEmpty(outputDirectory))
                 return false;
 
             // Create the full output path

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,221 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
-using BinaryObjectScanner.Interfaces;
-using BinaryObjectScanner.Utilities;
-using static BinaryObjectScanner.Utilities.Dictionary;
-
-namespace BinaryObjectScanner
-{
-    internal static class Handler
-    {
-        #region Public Collections
-
-        /// <summary>
-        /// Cache for all IPathCheck types
-        /// </summary>
-        public static IEnumerable<IPathCheck?> PathCheckClasses
-        {
-            get
-            {
-                if (pathCheckClasses == null)
-                    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 ConcurrentDictionary<string, ConcurrentQueue<string>> HandlePathChecks(string path, IEnumerable<string>? files)
-        {
-            // Create the output dictionary
-            var protections = new ConcurrentDictionary<string, ConcurrentQueue<string>>();
-
-            // Preprocess the list of files
-            files = files?.Select(f => f.Replace('\\', '/'))?.ToList();
-
-            // Iterate through all checks
-            Parallel.ForEach(PathCheckClasses, checkClass =>
-            {
-                var subProtections = checkClass?.PerformCheck(path, files);
-                if (subProtections != null)
-                    AppendToDictionary(protections, 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 ConcurrentQueue<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">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="scanner">Scanner object to use on extractable contents</param>
-        /// <returns>Set of protections in file, null on error</returns>
-        public static ConcurrentDictionary<string, ConcurrentQueue<string>>? 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
-                StripFromKeys(subProtections, tempPath);
-                PrependToKeys(subProtections, 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 ConcurrentQueue<string>? PerformCheck(this IPathCheck impl, string? path, IEnumerable<string>? files)
-        {
-            // If we have an invalid path
-            if (string.IsNullOrWhiteSpace(path))
-                return null;
-
-            // Setup the output dictionary
-            var protections = new ConcurrentQueue<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>(typeof(Handler).Assembly);
-
-        /// <summary>
-        /// Initialize all implementations of a type
-        /// </summary>
-        private static IEnumerable<T?> InitCheckClasses<T>(Assembly assembly)
-        {
-            return assembly.GetTypes()?
-                .Where(t => t.IsClass && t.GetInterface(typeof(T).Name) != null)?
-                .Select(t => (T?)Activator.CreateInstance(t)) ?? [];
-        }
-
-        #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 ConcurrentQueue<string>? ProcessProtectionString(string? protection)
-        {
-            // If we have an invalid protection string
-            if (string.IsNullOrWhiteSpace(protection))
-                return null;
-
-            // Setup the output queue
-            var protections = new ConcurrentQueue<string>();
-
-            // If we have an indicator of multiple protections
-            if (protection!.Contains(";"))
-            {
-                var splitProtections = protection.Split(';');
-                protections.AddRange(splitProtections);
-            }
-            else
-            {
-                protections.Enqueue(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/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/IPathCheck.cs

@@ -1,5 +1,4 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace BinaryObjectScanner.Interfaces
 {
@@ -17,7 +16,7 @@ namespace BinaryObjectScanner.Interfaces
         /// <param name="path">Path to check for protection indicators</param>
         /// <param name="files">Enumerable of strings representing files in a directory</param>
         /// <remarks>This can do some limited content checking as well, but it's suggested to use a content check instead, if possible</remarks>
-        ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files);
+        IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files);
 
         /// <summary>
         /// Check a file path for protections based on path name

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

@@ -1,17 +1,17 @@
 using System.Collections.Generic;
-using System.IO;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
-    public class ASPack : IExtractable, 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;
@@ -29,7 +29,7 @@ namespace BinaryObjectScanner.Packer
             // {
             //     var matchers = GenerateMatchers();
             //     var match = MatchUtil.GetFirstMatch(file, pex.EntryPointRaw, matchers, includeDebug);
-            //     if (!string.IsNullOrWhiteSpace(match))
+            //     if (!string.IsNullOrEmpty(match))
             //         return match;
             // }
 
@@ -42,7 +42,7 @@ namespace BinaryObjectScanner.Packer
                 {
                     var matchers = GenerateMatchers();
                     var match = MatchUtil.GetFirstMatch(file, adataSectionRaw, matchers, includeDebug);
-                    if (!string.IsNullOrWhiteSpace(match))
+                    if (!string.IsNullOrEmpty(match))
                         return match;
                 }
             }
@@ -51,21 +51,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
 
         /// <summary>
@@ -78,7 +66,7 @@ namespace BinaryObjectScanner.Packer
             {
                 #region No Wildcards (Long)
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x92, 0x1A, 0x44, 0x00, 0xB8, 0x8C, 0x1A,
@@ -87,7 +75,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0xC4, 0x1D, 0x44,
                 }, "ASPack 1.00b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xD2, 0x2A, 0x44, 0x00, 0xB8, 0xCC, 0x2A,
@@ -101,7 +89,7 @@ namespace BinaryObjectScanner.Packer
                     0x44, 0x00, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.01b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xD2, 0x2A, 0x44, 0x00, 0xB8, 0xCC, 0x2A,
@@ -110,7 +98,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x9C, 0x2E, 0x44
                 }, "ASPack 1.01b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x96, 0x78, 0x43, 0x00, 0xB8, 0x90, 0x78,
@@ -124,7 +112,7 @@ namespace BinaryObjectScanner.Packer
                     0x43, 0x00, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.02b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x96, 0x78, 0x43, 0x00, 0xB8, 0x90, 0x78,
@@ -134,7 +122,7 @@ namespace BinaryObjectScanner.Packer
                     0x15, 0xFE, 0x85, 0x74, 0x7C, 0x43
                 }, "ASPack 1.02b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x8A, 0x1C, 0x40, 0x00, 0xB9, 0x9E, 0x00,
@@ -142,14 +130,14 @@ namespace BinaryObjectScanner.Packer
                     0x8B, 0xF7, 0x33
                 }, "ASPack 1.02b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x96, 0x78, 0x43, 0x00, 0xB8, 0x90, 0x78,
                     0x43, 0x00, 0x03, 0xC5
                 }, "ASPack 1.02b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xAE, 0x98, 0x43, 0x00, 0xB8, 0xA8, 0x98,
@@ -158,7 +146,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x0E, 0x9D, 0x43
                 }, "ASPack 1.03b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xCE, 0x3A, 0x44, 0x00, 0xB8, 0xC8, 0x3A,
@@ -167,7 +155,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0xAC, 0x3E, 0x44
                 }, "ASPack 1.05b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xEA, 0xA8, 0x43, 0x00, 0xB8, 0xE4, 0xA8,
@@ -181,7 +169,7 @@ namespace BinaryObjectScanner.Packer
                     0x43, 0x00, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.06.01b (DLL)"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0xEA, 0xA8, 0x43, 0x00, 0xB8, 0xE4, 0xA8,
@@ -191,7 +179,7 @@ namespace BinaryObjectScanner.Packer
                     0x15, 0xFE, 0x85, 0x6E, 0xAD, 0x43
                 }, "ASPack 1.06.01b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x3E, 0xD9, 0x43, 0x00, 0xB8, 0x38, 0xD9,
@@ -205,7 +193,7 @@ namespace BinaryObjectScanner.Packer
                     0x43, 0x00, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.07b (DLL)"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xEB, 0x03, 0x5D, 0xFF, 0xE5, 0xE8, 0xF8,
                     0xFF, 0xFF, 0xFF, 0x81, 0xED, 0x1B, 0x6A, 0x44,
@@ -213,7 +201,7 @@ namespace BinaryObjectScanner.Packer
                     0x2B, 0x9D, 0x2A
                 }, "ASPack 1.08"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x0A, 0x4A, 0x44, 0x00, 0xBB, 0x04, 0x4A,
@@ -227,7 +215,7 @@ namespace BinaryObjectScanner.Packer
                     0x53, 0x50, 0xFF, 0x95, 0x90, 0x51, 0x44, 0x00
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x0A, 0x4A, 0x44, 0x00, 0xBB, 0x04, 0x4A,
@@ -236,20 +224,20 @@ namespace BinaryObjectScanner.Packer
                     0x00, 0x89, 0x9D, 0xBB, 0x4E
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x0A, 0x4A, 0x44, 0x00, 0xBB, 0x04, 0x4A,
                     0x44, 0x00, 0x03, 0xDD
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x72, 0x05, 0x00, 0x00, 0xEB, 0x33,
                     0x87, 0xDB, 0x90, 0x00
                 }, "ASPack 2.00.01"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9, 0xEB,
                     0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01, 0x00,
@@ -257,34 +245,34 @@ namespace BinaryObjectScanner.Packer
                     0xFF, 0x03, 0xDD, 0x81, 0xEB
                 }, "ASPack 2.1"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x02, 0x00, 0x00, 0x00, 0xEB, 0x09,
                     0x5D, 0x55, 0x81, 0xED, 0x39, 0x39, 0x44, 0x00,
                     0xC3, 0xE9, 0x3D, 0x04, 0x00, 0x00
                 }, "ASPack 2.11b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x02, 0x00, 0x00, 0x00, 0xEB, 0x09,
                     0x5D, 0x55
                 }, "ASPack 2.11b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x02, 0x00, 0x00, 0x00, 0xEB, 0x09,
                     0x5D, 0x55, 0x81, 0xED, 0x39, 0x39, 0x44, 0x00,
                     0xC3, 0xE9, 0x59, 0x04, 0x00, 0x00
                 }, "ASPack 2.11c"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x02, 0x00, 0x00, 0x00, 0xCD, 0x20,
                     0xE8, 0x00, 0x00, 0x00, 0x00, 0x5E, 0x2B, 0xC9,
                     0x58, 0x74, 0x02
                 }, "ASPack 2.11d"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9, 0xEB,
                     0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01
@@ -294,7 +282,7 @@ namespace BinaryObjectScanner.Packer
 
                 #region Wildcards (Long)
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0x3E, 0xD9, 0x43, null, 0xB8, 0x38, null,
@@ -308,7 +296,7 @@ namespace BinaryObjectScanner.Packer
                     0x43, null, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.00b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0xD2, 0x2A, 0x44, null, 0xB8, 0xCC, 0x2A,
@@ -317,7 +305,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x9C, 0x2E, 0x44
                 }, "ASPack 1.01b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0xCE, 0x3A, 0x44, null, 0xB8, 0xC8, 0x3A,
@@ -326,7 +314,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0xAC, 0x3E, 0x44
                 }, "ASPack 1.01b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, 0x3E, 0xD9, 0x43, 0x00, 0xB8, 0x38, null,
@@ -340,13 +328,13 @@ namespace BinaryObjectScanner.Packer
                     0x43, 0x00, 0x89, 0x44, 0x24, 0x1C, 0x61, 0xFF
                 }, "ASPack 1.02a -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0x06, null, null, null, 0x64, 0xA0, 0x23
                 }, "ASPack 1.02a"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0x96, 0x78, 0x43, null, 0xB8, 0x90, 0x78,
@@ -355,7 +343,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x74, 0x7C, 0x43
                 }, "ASPack 1.02b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0xAE, 0x98, 0x43, null, 0xB8, 0xA8, 0x98,
@@ -364,7 +352,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x0E, 0x9D, 0x43
                 }, "ASPack 1.03b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, null, null, null, null, 0xE8, 0x0D, null,
@@ -372,7 +360,7 @@ namespace BinaryObjectScanner.Packer
                     null, null, null, null, null, null, null, 0x58
                 }, "ASPack 1.03b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81,
                     0xED, null, null, null, 0x00, 0xB8, null, null,
@@ -381,7 +369,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x08, 0x9D, null, 0x00, 0x00
                 }, "ASPack 1.04b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, null, null, null, null, 0xB8, null, null,
@@ -390,7 +378,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x08, 0x9D
                 }, "ASPack 1.04b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, null, null, null, null, 0xB8, null, null,
@@ -399,7 +387,7 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x01, 0xDE
                 }, "ASPack 1.04b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, 0xEA, 0xA8, 0x43, null, 0xB8, 0xE4, 0xA8,
@@ -408,28 +396,28 @@ namespace BinaryObjectScanner.Packer
                     0x80, 0xBD, 0x6E, 0xAD, 0x43
                 }, "ASPack 1.06.1b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x90, 0x61, 0xBE, null, null, null, null, 0x8D,
                     0xBE, null, null, null, null, 0x57, 0x83, 0xCD,
                     0xFF
                 }, "ASPack 1.06.1b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, null,
                     null, null, null, null, null, 0xB8, null, null,
                     null, null, 0x03, 0xC5
                 }, "ASPack 1.07b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, null, null, null, null, 0x5D, 0x81,
                     0xED, null, null, null, null, 0x60, 0xE8, 0x2B,
                     0x03, 0x00, 0x00
                 }, "ASPack 1.07b"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xEB, 0x0A, 0x5D, 0xEB, 0x02, 0xFF, 0x25,
                     0x45, 0xFF, 0xE5, 0xE8, 0xE9, 0xE8, 0xF1, 0xFF,
@@ -438,7 +426,7 @@ namespace BinaryObjectScanner.Packer
                     0x2B, 0x9D
                 }, "ASPack 1.08.01"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xEB, 0x0A, 0x5D, 0xEB, 0x02, 0xFF, 0x25,
                     0x45, 0xFF, 0xE5, 0xE8, 0xE9, 0xE8, 0xF1, 0xFF,
@@ -447,7 +435,7 @@ namespace BinaryObjectScanner.Packer
                     0x2B, 0x9D
                 }, "ASPack 1.08.01"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xEB, 0x0A, 0x5D, 0xEB, 0x02, 0xFF, 0x25,
                     0x45, 0xFF, 0xE5, 0xE8, 0xE9, 0xE8, 0xF1, 0xFF,
@@ -456,7 +444,7 @@ namespace BinaryObjectScanner.Packer
                     0x2B, 0x9D, 0x72
                 }, "ASPack 1.08.02"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, null,
                     null, null, null, null, null, 0xBB, null, null,
@@ -465,14 +453,14 @@ namespace BinaryObjectScanner.Packer
                     0x00, 0x89, 0x9D, 0xBB, 0x4E
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, null,
                     null, null, null, null, null, 0xBB, null, null,
                     null, null, 0x03, 0xDD
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x55, 0x57, 0x51, 0x53, 0xE8, null, null, null,
                     null, 0x5D, 0x8B, 0xC5, 0x81, 0xED, null, null,
@@ -481,27 +469,27 @@ namespace BinaryObjectScanner.Packer
                     null, 0x0F, 0xB6
                 }, "ASPack 1.08.03"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE9, null, null, null, null, 0xEF, 0x40,
                     0x03, 0xA7, 0x07, 0x8F, 0x07, 0x1C, 0x37, 0x5D,
                     0x43, 0xA7, 0x04, 0xB9, 0x2C, 0x3A
                 }, "ASPack 1.08.x"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x02, 0x00, 0x00, 0x00, 0xEB, 0x09,
                     0x5D, 0x55, 0x81, 0xED, 0x39, 0x39, 0x44, 0x00,
                     0xC3, 0xE9, null, 0x04, 0x00, 0x00
                 }, "ASPack 2.11.x -> Alexey Solodovnikov"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     null, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9, 0xEB,
                     0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01
                 }, "ASPack 2.12 (without Poly) -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     null, 0x60, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9,
                     0xEB, 0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01,
@@ -518,7 +506,7 @@ namespace BinaryObjectScanner.Packer
                     0xFF, 0x95, 0x48, 0x0F
                 }, "ASPack 2.12b -> Solodovnikov Alexey"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x60, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9, 0xEB,
                     0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01, 0x00,
@@ -567,7 +555,7 @@ namespace BinaryObjectScanner.Packer
                     0x08
                 }, "ASPack 2.2 -> Alexey Solodovnikov & StarForce * 2009408"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     null, 0x60, 0xE8, 0x03, 0x00, 0x00, 0x00, 0xE9,
                     0xEB, 0x04, 0x5D, 0x45, 0x55, 0xC3, 0xE8, 0x01,
@@ -580,7 +568,7 @@ namespace BinaryObjectScanner.Packer
 
                 #region 2.xx (Long)
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0xA8, 0x03, 0x00, 0x00, 0x61, 0x75, 0x08, 0xB8,
                     0x01, 0x00, 0x00, 0x00, 0xC2, 0x0C, 0x00, 0x68,
@@ -589,7 +577,7 @@ namespace BinaryObjectScanner.Packer
                     0x00, 0x51, 0x50, 0xFF, 0x95
                 }, "ASPack 2.xx"),
 
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0xA8, 0x03, null, null, 0x61, 0x75, 0x08, 0xB8,
                     0x01, null, null, null, 0xC2, 0x0C, null, 0x68,
@@ -602,55 +590,55 @@ namespace BinaryObjectScanner.Packer
 
                 #region Short
 
-                new ContentMatchSet(new byte?[] { 0x75, 0x00, 0xE9 }, "ASPack 1.05b"),
+                new(new byte?[] { 0x75, 0x00, 0xE9 }, "ASPack 1.05b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
+                new(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
+                new(new byte?[] { 0x90, 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
+                new(new byte?[] { 0x90, 0x75, 0x00, 0xE9 }, "ASPack 1.06.1b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
+                new(new byte?[] { 0x90, 0x90, 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
+                new(new byte?[] { 0x90, 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
+                new(new byte?[] { 0x90, 0x75, null, 0xE9 }, "ASPack 1.07b"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08"),
+                new(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
+                new(new byte?[] { 0x90, 0x90, 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
+                new(new byte?[] { 0x90, 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
+                new(new byte?[] { 0x90, 0x75, 0x01, 0xFF, 0xE9 }, "ASPack 1.08"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
+                new(new byte?[] { 0x90, 0x90, 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
+                new(new byte?[] { 0x90, 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
+                new(new byte?[] { 0x90, 0x75, null, 0x90, 0xE9 }, "ASPack 1.08.01"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08.02"),
+                new(new byte?[] { 0x90, 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08.02"),
 
-                new ContentMatchSet(new byte?[] { 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08.02"),
+                new(new byte?[] { 0x90, 0x75, 0x01, 0x90, 0xE9 }, "ASPack 1.08.02"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0x41, 0x06, 0x00, 0x00, 0xEB, 0x41 }, "ASPack 1.08.04"),
+                new(new byte?[] { 0x60, 0xE8, 0x41, 0x06, 0x00, 0x00, 0xEB, 0x41 }, "ASPack 1.08.04"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, null, null, null, null, 0xEB }, "ASPack 1.08.04"),
+                new(new byte?[] { 0x60, 0xE8, null, null, null, null, 0xEB }, "ASPack 1.08.04"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0x70, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.00"),
+                new(new byte?[] { 0x60, 0xE8, 0x70, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.00"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0x48, 0x11, 0x00, 0x00, 0xC3, 0x83 }, "ASPack 2.00.00"),
+                new(new byte?[] { 0x60, 0xE8, 0x48, 0x11, 0x00, 0x00, 0xC3, 0x83 }, "ASPack 2.00.00"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0x72, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.01"),
+                new(new byte?[] { 0x60, 0xE8, 0x72, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.01"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, null, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.x -> Alexey Solodovnikov"),
+                new(new byte?[] { 0x60, 0xE8, null, 0x05, 0x00, 0x00, 0xEB, 0x4C }, "ASPack 2.00.x -> Alexey Solodovnikov"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE9, 0x3D, 0x04, 0x00, 0x00 }, "ASPack 2.11"),
+                new(new byte?[] { 0x60, 0xE9, 0x3D, 0x04, 0x00, 0x00 }, "ASPack 2.11"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0xF9, 0x11, 0x00, 0x00, 0xC3, 0x83 }, "ASPack 2.11"),
+                new(new byte?[] { 0x60, 0xE8, 0xF9, 0x11, 0x00, 0x00, 0xC3, 0x83 }, "ASPack 2.11"),
 
-                new ContentMatchSet(new byte?[] { 0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81, 0xED }, "ASPack 1.02b/1.08.03"),
+                new(new byte?[] { 0x60, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x81, 0xED }, "ASPack 1.02b/1.08.03"),
 
                 #endregion
             };

BinaryObjectScanner/Packer/AdvancedInstaller.cs

@@ -1,6 +1,3 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // TODO: Verify that all versions are detected
-    public class AdvancedInstaller : IExtractable, 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;
@@ -22,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";
             }
 
@@ -30,21 +27,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/Armadillo.cs

@@ -1,62 +0,0 @@
-using System.IO;
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Packer
-{
-    // TODO: Add extraction
-    // TODO: Add version checking, if possible
-    // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class Armadillo : IExtractable, IPortableExecutableCheck
-    {
-        /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
-        {
-            // Get the sections from the executable, if possible
-            var sections = pex.Model.SectionTable;
-            if (sections == null)
-                return null;
-
-            // Get the .nicode section, if it exists
-            bool nicodeSection = pex.ContainsSection(".nicode", exact: true);
-            if (nicodeSection)
-                return "Armadillo";
-
-            // 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")))
-                {
-                    // Get the section strings, if they exist
-                    var strs = pex.GetFirstSectionStrings(sectionName);
-                    if (strs != null)
-                    {
-                        if (strs.Any(s => s.Contains("ARMDEBUG")))
-                            return "Armadillo";
-                    }
-                }
-            }
-
-            return null;
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
-        {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
-        }
-    }
-}

BinaryObjectScanner/Packer/AutoPlayMediaStudio.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,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 : IExtractable, 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;
@@ -34,21 +33,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/CExe.cs

@@ -3,10 +3,9 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
-#if NET462_OR_GREATER
-using ICSharpCode.SharpZipLib.Zip.Compression;
-#endif
+using SabreTools.Compression.zlib;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
@@ -14,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 : IExtractable, 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;
@@ -32,7 +31,7 @@ namespace BinaryObjectScanner.Packer
             {
                 var matchers = new List<ContentMatchSet>
             {
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x25, 0x57, 0x6F, 0xC1, 0x61, 0x36, 0x01, 0x92,
                     0x61, 0x36, 0x01, 0x92, 0x61, 0x36, 0x01, 0x92,
@@ -44,7 +43,7 @@ namespace BinaryObjectScanner.Packer
             };
 
                 var match = MatchUtil.GetFirstMatch(file, pex.StubExecutableData, matchers, includeDebug);
-                if (!string.IsNullOrWhiteSpace(match))
+                if (!string.IsNullOrEmpty(match))
                     return match;
             }
 
@@ -52,31 +51,14 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
-        {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             try
             {
-                // Parse into an executable again for easier extraction
-                var pex = PortableExecutable.Create(stream);
-                if (pex == null)
-                    return null;
-
                 // 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();
@@ -90,16 +72,34 @@ namespace BinaryObjectScanner.Packer
                     try
                     {
                         // Inflate the data into the buffer
-#if NET462_OR_GREATER
-                        Inflater inflater = new Inflater();
-                        inflater.SetInput(payload);
+                        var zstream = new ZLib.z_stream_s();
                         data = new byte[payload.Length * 4];
-                        int read = inflater.Inflate(data);
+                        unsafe
+                        {
+                            fixed (byte* payloadPtr = payload)
+                            fixed (byte* dataPtr = data)
+                            {
+                                zstream.next_in = payloadPtr;
+                                zstream.avail_in = (uint)payload.Length;
+                                zstream.total_in = (uint)payload.Length;
+                                zstream.next_out = dataPtr;
+                                zstream.avail_out = (uint)data.Length;
+                                zstream.total_out = 0;
+
+                                ZLib.inflateInit_(zstream, ZLib.zlibVersion(), payload.Length);
+                                int zret = ZLib.inflate(zstream, 1);
+                                ZLib.inflateEnd(zstream);
+                            }
+                        }
 
                         // Trim the buffer to the proper size
-                        data = new ReadOnlySpan<byte>(data, 0, read).ToArray();
+                        uint read = zstream.total_out;
+#if NETFRAMEWORK
+                        var temp = new byte[read];
+                        Array.Copy(data, 0, temp, 0, read);
+                        data = temp;
 #else
-                        data = null;
+                        data = new ReadOnlySpan<byte>(data, 0, (int)read).ToArray();
 #endif
                     }
                     catch
@@ -109,7 +109,7 @@ namespace BinaryObjectScanner.Packer
                     }
                 }
 
-                // Otherwise, LZ is used via the Windows API
+                // Otherwise, LZ is used
                 else
                 {
                     try
@@ -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

@@ -0,0 +1,34 @@
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Serialization.Wrappers;
+
+namespace BinaryObjectScanner.Packer
+{
+    // TODO: Add extraction
+    public class DotFuscator : IExtractableExecutable<PortableExecutable>
+    {
+        /// <inheritdoc/>
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
+        {
+            // Get the sections from the executable, if possible
+            var sections = pex.Model.SectionTable;
+            if (sections == null)
+                return null;
+
+            // Get the .text section strings, if they exist
+            var strs = pex.GetFirstSectionStrings(".text");
+            if (strs != null)
+            {
+                if (strs.Exists(s => s.Contains("DotfuscatorAttribute")))
+                    return "dotFuscator";
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
+        {
+            return false;
+        }
+    }
+}

BinaryObjectScanner/Packer/DotNetReactor.cs

@@ -0,0 +1,106 @@
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Serialization.Wrappers;
+using System.Collections.Generic;
+using SabreTools.Matching;
+using SabreTools.Matching.Content;
+
+namespace BinaryObjectScanner.Packer
+{
+    /// <summary>
+    /// .NET Reactor is a .NET obfuscator that was original released in 2004. https://web.archive.org/web/20040828162124/http://eziriz.com:80/
+    /// It is currently still being updated and supported. https://www.eziriz.com/dotnet_reactor.htm
+    /// While ProtectionID does detect .NET Reactor, it's currently unknown exactly how. 
+    /// It seems to simply check for the string "<PrivateImplementationDetails>" in specific, and currently unknown, conditions but appears to be prone to false positives.
+    /// A "Demo/Nag Screen" version is available for free, and may be able to be used to make samples to improve detections. https://www.eziriz.com/reactor_download.htm
+    /// 
+    /// Resource that could be useful for extraction: https://github.com/SychicBoy/NETReactorSlayer
+    /// </summary>
+    public class DotNetReactor : IExtractableExecutable<PortableExecutable>
+    {
+        /// <inheritdoc/>
+        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
+            // Get the sections from the executable, if possible
+            var sections = pex.Model.SectionTable;
+            if (sections == null)
+                return null;
+
+            // Get the .text section, if it exists
+            if (pex.ContainsSection(".text"))
+            {
+                var textData = pex.GetFirstSectionData(".text");
+                if (textData != null)
+                {
+                    var matchers = new List<ContentMatchSet>
+                    {
+                        // Adapted from https://github.com/cod3nym/detection-rules/blob/main/yara/dotnet/obf_net_reactor.yar and confirmed to work with "KalypsoLauncher.dll" from Redump entry 95617.
+                        // <PrivateImplementationDetails>{[8]-[4]-[4]-[4]-[12]}
+                        new(new byte?[]
+                        {
+                            0x3C, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65,
+                            0x49, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 
+                            0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x65,
+                            0x74, 0x61, 0x69, 0x6C, 0x73, 0x3E, 0x7B, null, 
+                            null, null, null, null, null, null, null, 0x2D,
+                            null, null, null, null, 0x2D, null, null, null,
+                            null, 0x2D, null, null, null, null, 0x2D, null,
+                            null, null, null, null, null, null, null, null,
+                            null, null, null, 0x7D
+                        }, ".NET Reactor"),
+
+                        // Modified from the previous detection to detect a presumably newer version of .NET Reactor found in "KalypsoLauncher.dll" version 2.0.4.2. 
+                        // TODO: Check if this can/should be made more specific.
+                        // <PrivateImplementationDetails>.RSA
+                        new(new byte?[]
+                        {
+                            0x3C, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65,
+                            0x49, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 
+                            0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x65,
+                            0x74, 0x61, 0x69, 0x6C, 0x73, 0x3E, 0x00, 0x52,
+                            0x53, 0x41
+                        }, ".NET Reactor"),
+
+                        // Adapted from https://github.com/cod3nym/detection-rules/blob/main/yara/dotnet/obf_net_reactor.yar and confirmed to work with "KalypsoLauncher.dll" from Redump entry 95617.
+                        // 3{.[9].-.[9].-.[9].}
+                        new(new byte?[]
+                        {
+                            0x33, 0x7B, 0x00, null, null, null, null, null, 
+                            null, null, null, null, 0x00, 0x2D, 0x00, null, 
+                            null, null, null, null, null, null, null, null, 
+                            0x00, 0x2D, 0x00, null, null, null, null, null, 
+                            null, null, null, null, 0x00, 0x2D, 0x00, null, 
+                            null, null, null, null, null, null, null, null, 
+                            0x00, 0x7D, 0x00 
+                        }, ".NET Reactor (Unconfirmed - Please report to us on GitHub)"),
+                        
+                        // Adapted from https://github.com/cod3nym/detection-rules/blob/main/yara/dotnet/obf_net_reactor.yar and confirmed to work with "KalypsoLauncher.dll" from Redump entry 95617.
+                        // <Module>{[8]-[4]-[4]-[4]-[12]}
+                        new(new byte?[]
+                        {
+                            0x3C, 0x4D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x3E, 
+                            0x7B, null, null, null, null, null, null, null, 
+                            null, 0x2D, null, null, null, null, 0x2D, null, 
+                            null, null, null, 0x2D, null, null, null, null, 
+                            0x2D, null, null, null, null, null, null, null, 
+                            null, null, null, null, null, 0x7D
+                        }, ".NET Reactor (Unconfirmed - Please report to us on GitHub)")
+                    };
+
+                    return MatchUtil.GetFirstMatch(file, textData, matchers, includeDebug);
+                }
+            }
+
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
+        {
+            // TODO: Add extraction
+            return false;
+        }
+    }
+}

BinaryObjectScanner/Packer/EXEStealth.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
-using System.IO;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
@@ -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, IExtractable, IPortableExecutableCheck
+    public class EXEStealth : IContentCheck, IExtractableExecutable<PortableExecutable>
     {
         /// <inheritdoc/>
         public string? CheckContents(string file, byte[] fileContent, bool includeDebug)
@@ -21,7 +21,7 @@ namespace BinaryObjectScanner.Packer
                 var contentMatchSets = new List<ContentMatchSet>
                  {
                      // ??[[__[[_ + (char)0x00 + {{ + (char)0x0 + (char)0x00 + {{ + (char)0x00 + (char)0x00 + (char)0x00 + (char)0x00 + (char)0x0 + (char)0x00 + (char)0x00 + (char)0x00 + (char)0x00 + ?;??;??
-                     new ContentMatchSet(new byte?[]
+                     new(new byte?[]
                      {
                          0x3F, 0x3F, 0x5B, 0x5B, 0x5F, 0x5F, 0x5B, 0x5B,
                          0x5F, 0x00, 0x7B, 0x7B, 0x00, 0x00, 0x7B, 0x7B,
@@ -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,21 +75,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, 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 : IExtractable, 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,44 +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, bool includeDebug)
-        {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
             try
             {
-                // Parse into an executable again for easier extraction
-                var pex = PortableExecutable.Create(stream);
-                if (pex?.ResourceData == null)
-                    return null;
+                // If there are no resources
+                if (pex.ResourceData == 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
@@ -71,14 +66,14 @@ 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))
-                        {
-                            if (tempStream != null)
-                                tempStream.Write(data, 0, data.Length);
-                        }
+                        using var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
+                        tempStream?.Write(data, 0, data.Length);
                     }
                     catch (Exception ex)
                     {
@@ -86,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,6 +1,3 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,10 +5,10 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class GenteeInstaller : IExtractable, 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;
@@ -22,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";
             }
 
@@ -33,21 +30,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/HyperTechCrackProof.cs

@@ -1,5 +1,4 @@
-using System.IO;
-using System.Linq;
+using System;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -10,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 : IExtractable, 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;
@@ -23,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";
@@ -32,21 +32,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/InnoSetup.cs

@@ -1,24 +1,24 @@
 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction - https://github.com/dscharrer/InnoExtract
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class InnoSetup : IExtractable, 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)
             {
                 string version = GetOldVersion(file, nex);
-                if (!string.IsNullOrWhiteSpace(version))
+                if (!string.IsNullOrEmpty(version))
                     return $"Inno Setup {version}";
                 
                 return "Inno Setup (Unknown Version)";
@@ -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,21 +54,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
 
         private static string GetOldVersion(string file, NewExecutable nex)
@@ -85,7 +73,7 @@ namespace BinaryObjectScanner.Packer
                 var matchers = new List<ContentMatchSet>
                 {
                     // "rDlPtS02" + (char)0x87 + "eVx"
-                    new ContentMatchSet(new byte?[] { 0x72, 0x44, 0x6C, 0x50, 0x74, 0x53, 0x30, 0x32, 0x87, 0x65, 0x56, 0x78 }, "1.2.16 or earlier"),
+                    new(new byte?[] { 0x72, 0x44, 0x6C, 0x50, 0x74, 0x53, 0x30, 0x32, 0x87, 0x65, 0x56, 0x78 }, "1.2.16 or earlier"),
                 };
 
                 return MatchUtil.GetFirstMatch(file, data, matchers, false) ?? "Unknown 1.X";

BinaryObjectScanner/Packer/InstallAnywhere.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -7,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 : IExtractable, 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;
@@ -29,21 +28,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
 
         private string GetVersion(PortableExecutable pex)

BinaryObjectScanner/Packer/InstallerVISE.cs

@@ -1,6 +1,3 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,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 : IExtractable, 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;
@@ -23,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";
             }
             
@@ -31,21 +28,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/IntelInstallationFramework.cs

@@ -1,15 +1,14 @@
 using System;
-using System.IO;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction, seems to primarily use MSZip compression.
-    public class IntelInstallationFramework : IExtractable, 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;
@@ -34,21 +33,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/MicrosoftCABSFX.cs

@@ -1,6 +1,4 @@
 using System;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,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 : IExtractable, 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;
@@ -30,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)}";
             }
 
@@ -40,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)}";
             }
 
@@ -48,28 +46,16 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            return false;
         }
 
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
-        }
-    
         private string GetVersion(PortableExecutable pex)
         {
             // Check the internal versions
             var version = pex.GetInternalVersion();
-            if (!string.IsNullOrWhiteSpace(version))
+            if (!string.IsNullOrEmpty(version))
                 return $"v{version}";
 
             return string.Empty;

BinaryObjectScanner/Packer/NSIS.cs

@@ -1,16 +1,13 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
-    public class NSIS : IExtractable, 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;
@@ -18,14 +15,14 @@ namespace BinaryObjectScanner.Packer
                 return null;
 
             var description = pex.AssemblyDescription;
-            if (!string.IsNullOrWhiteSpace(description) && description!.StartsWith("Nullsoft Install System"))
+            if (!string.IsNullOrEmpty(description) && description!.StartsWith("Nullsoft Install System"))
                 return $"NSIS {description.Substring("Nullsoft Install System".Length).Trim()}";
 
             // Get the .data/DATA section strings, if they exist
             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";
             }
 
@@ -33,21 +30,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/NeoLite.cs

@@ -1,5 +1,4 @@
-using System.IO;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
@@ -14,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 : IExtractable, 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;
@@ -37,22 +36,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            // TODO: Add extraction
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/PECompact.cs

@@ -1,15 +1,14 @@
-using System.IO;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Better version detection - https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
     // TODO: Add extraction
-    public class PECompact : IExtractable, 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;
@@ -42,21 +41,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/Petite.cs

@@ -1,15 +1,14 @@
-using System.IO;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class PEtite : IExtractable, 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;
@@ -25,21 +24,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/SetupFactory.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
@@ -8,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 : IExtractable, 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;
@@ -39,23 +38,11 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
+            return false;
         }
 
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
-        }
-    
         private string GetVersion(PortableExecutable pex)
         {
             // Check the product version explicitly

BinaryObjectScanner/Packer/SevenZipSFX.cs

@@ -1,15 +1,13 @@
-using System.IO;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Packer
 {
-    // TODO: Add extraction
-    public class SevenZipSFX : IExtractable, 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;
@@ -19,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";
@@ -46,21 +44,10 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            var sevenZip = new FileType.SevenZip();
+            return sevenZip.Extract(file, outDir, lookForHeader: true, includeDebug);
         }
     }
 }

BinaryObjectScanner/Packer/Shrinker.cs

@@ -1,4 +1,3 @@
-using System.IO;
 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 Shrinker : IExtractable, 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;
@@ -26,21 +25,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
+            return false;
         }
     }
 }

BinaryObjectScanner/Packer/UPX.cs

@@ -1,6 +1,4 @@
 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using BinaryObjectScanner.Interfaces;
@@ -10,14 +8,14 @@ namespace BinaryObjectScanner.Packer
 {
     // TODO: Add extraction
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class UPX : IExtractable, 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;
@@ -25,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);
@@ -41,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)
@@ -50,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)
@@ -64,21 +62,9 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, 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
-using SharpCompress.Archives;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Readers;
-#endif
 
 namespace BinaryObjectScanner.Packer
 {
-    public class WinRARSFX : IExtractable, 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,60 +26,10 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-#if NET462_OR_GREATER
-            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 zipFile = RarArchive.Open(file, new ReaderOptions() { LookForHeader = true }))
-                {
-                    if (!zipFile.IsComplete)
-                        return null;
-
-                    string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                    Directory.CreateDirectory(tempPath);
-
-                    foreach (var entry in zipFile.Entries)
-                    {
-                        try
-                        {
-                            // If we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
-
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            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,29 +1,26 @@
-using System;
-using System.IO;
 using System.Linq;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
-#if NET462_OR_GREATER
-using SharpCompress.Archives;
-using SharpCompress.Archives.Zip;
-#endif
 
 namespace BinaryObjectScanner.Packer
 {
-    public class WinZipSFX : IExtractable, 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)
                 return null;
 
-            // Check for the WinZip name string
+            // Check for the WinZip name strings
             bool winZipNameFound = nex.Model.ResidentNameTable
                 .Select(rnte => rnte?.NameString == null ? string.Empty : Encoding.ASCII.GetString(rnte.NameString))
                 .Any(s => s.Contains("WZ-SE-01"));
+            winZipNameFound |= nex.Model.NonResidentNameTable?
+                .Select(nrnte => nrnte?.NameString == null ? string.Empty : Encoding.ASCII.GetString(nrnte.NameString))
+                .Any(s => s.Contains("WinZip(R) Self-Extractor")) ?? false;
 
             // If we didn't find it
             if (!winZipNameFound)
@@ -31,14 +28,14 @@ namespace BinaryObjectScanner.Packer
 
             // Try to get a known version
             var version = GetNEHeaderVersion(nex);
-            if (!string.IsNullOrWhiteSpace(version))
+            if (!string.IsNullOrEmpty(version))
                 return $"WinZip SFX {version}";
 
             return $"WinZip SFX Unknown Version (16-bit)";
         }
 
         /// <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;
@@ -49,7 +46,7 @@ namespace BinaryObjectScanner.Packer
             if (pex.Model.ExportTable?.ExportDirectoryTable != null)
             {
                 var version = GetPEExportDirectoryVersion(pex);
-                if (!string.IsNullOrWhiteSpace(version))
+                if (!string.IsNullOrEmpty(version))
                     return $"WinZip SFX {version}";
             }
 
@@ -63,60 +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, bool includeDebug)
-        {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
+        public bool Extract(string file, NewExecutable nex, string outDir, bool includeDebug)
+            => Extract(file, outDir, includeDebug);
 
         /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool 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 bool Extract(string file, string outDir, bool includeDebug)
         {
-#if NET462_OR_GREATER
-            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 (ZipArchive zipFile = ZipArchive.Open(file))
-                {
-                    if (!zipFile.IsComplete)
-                        return null;
-
-                    string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                    Directory.CreateDirectory(tempPath);
-
-                    foreach (var entry in zipFile.Entries)
-                    {
-                        try
-                        {
-                            // If we have a directory, skip it
-                            if (entry.IsDirectory)
-                                continue;
-
-                            string tempFile = Path.Combine(tempPath, entry.Key);
-                            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>
@@ -124,7 +81,7 @@ namespace BinaryObjectScanner.Packer
         /// </summary>
         /// TODO: Reduce the checks to only the ones that differ between versions
         /// TODO: Research to see if the versions are embedded elsewhere in these files
-        private string? GetNEHeaderVersion(NewExecutable nex)
+        private static string? GetNEHeaderVersion(NewExecutable nex)
         {
             #region 2.0 Variants
 
@@ -682,7 +639,7 @@ namespace BinaryObjectScanner.Packer
         /// Get the version from the PE export directory table value combinations
         /// </summary>
         /// TODO: Research to see if the versions are embedded elsewhere in these files
-        private string? GetPEExportDirectoryVersion(PortableExecutable pex)
+        private static string? GetPEExportDirectoryVersion(PortableExecutable pex)
         {
             string sfxFileName = pex.Model.ExportTable?.ExportDirectoryTable?.Name ?? string.Empty;
             uint sfxTimeDateStamp = pex.Model.ExportTable?.ExportDirectoryTable?.TimeDateStamp ?? uint.MaxValue;
@@ -693,37 +650,23 @@ namespace BinaryObjectScanner.Packer
                 || sfxFileName == "WZIPSE32.exe" || sfxFileName == "SI32LPG.SFX"
                 || sfxFileName == "ST32E.WZE")
             {
-                switch (sfxTimeDateStamp)
+                return sfxTimeDateStamp switch
                 {
-                    case 842636344:
-                        return "2.0 (32-bit)";
-                    case 865370756:
-                        return "2.1 RC2 (32-bit)";
-                    case 869059925:
-                        return "2.1 (32-bit)";
-                    case 979049321:
-                        return "2.2.4003";
-                    case 1149714685:
-                        return "3.0.7158";
-                    case 1185211734:
-                        return "3.1.7556";
-                    case 1185211920:
-                        return "3.1.7556";
-                    case 1235490556:
-                        return "4.0.8421";
-                    case 1235490757:
-                        return "4.0.8421";
-                    case 1235490687:
-                        return "4.0.8421"; // 3.1.8421.0, SI32LPG?
-                    case 1257193383:
-                        return "4.0.8672"; // 3.1.8672.0
-                    case 1257193543:
-                        return "4.0.8672";
-                    case 1470410848:
-                        return "4.0.12218"; // 4.0.1221.0
-                    default:
-                        return $"{assemblyVersion} (32-bit)";
-                }
+                    842636344 => "2.0 (32-bit)",
+                    865370756 => "2.1 RC2 (32-bit)",
+                    869059925 => "2.1 (32-bit)",
+                    979049321 => "2.2.4003",
+                    1149714685 => "3.0.7158",
+                    1185211734 => "3.1.7556",
+                    1185211920 => "3.1.7556",
+                    1235490556 => "4.0.8421",
+                    1235490757 => "4.0.8421",
+                    1235490687 => "4.0.8421",// 3.1.8421.0, SI32LPG?
+                    1257193383 => "4.0.8672",// 3.1.8672.0
+                    1257193543 => "4.0.8672",
+                    1470410848 => "4.0.12218",// 4.0.1221.0
+                    _ => $"{assemblyVersion} (32-bit)",
+                };
             }
 
             // Personal Edition
@@ -731,152 +674,90 @@ namespace BinaryObjectScanner.Packer
                 || sfxFileName == "wzsepe32.exe" || sfxFileName == "SI32PE.SFX"
                 || sfxFileName == "SI32LPE.SFX")
             {
-                switch (sfxTimeDateStamp)
+                return sfxTimeDateStamp switch
                 {
-                    case 845061601:
-                        return "Personal Edition (32-bit)"; // TODO: Find version
-                    case 868303343:
-                        return "Personal Edition (32-bit)"; // TODO: Find version
-                    case 868304170:
-                        return "Personal Edition (32-bit)"; // TODO: Find version
-                    case 906039079:
-                        return "Personal Edition 2.2.1260 (32-bit)";
-                    case 906040543:
-                        return "Personal Edition 2.2.1260 (32-bit)";
-                    case 908628435:
-                        return "Personal Edition 2.2.1285 (32-bit)";
-                    case 908628785:
-                        return "Personal Edition 2.2.1285 (32-bit)";
-                    case 956165981:
-                        return "Personal Edition 2.2.3063";
-                    case 956166038:
-                        return "Personal Edition 2.2.3063";
-                    case 1006353695:
-                        return "Personal Edition 2.2.4325";
-                    case 1006353714:
-                        return "Personal Edition 2.2.4325"; // 8.1.0.0
-                    case 1076515698:
-                        return "Personal Edition 2.2.6028";
-                    case 1076515784:
-                        return "Personal Edition 2.2.6028"; // 9.0.6028.0
-                    case 1092688561:
-                        return "Personal Edition 2.2.6224";
-                    case 1092688645:
-                        return "Personal Edition 2.2.6224"; // 9.0.6224.0
-                    case 1125074095:
-                        return "Personal Edition 2.2.6604";
-                    case 1125074162:
-                        return "Personal Edition 2.2.6604"; // 10.0.6604.0
-                    case 1130153399:
-                        return "Personal Edition 2.2.6663";
-                    case 1130153428:
-                        return "Personal Edition 2.2.6663"; // 10.0.6663.0
-                    case 1149714176:
-                        return "Personal Edition 3.0.7158";
-                    case 1163137967:
-                        return "Personal Edition 3.0.7305";
-                    case 1163137994:
-                        return "Personal Edition 3.0.7313"; // 11.0.7313.0
-                    case 1176345383:
-                        return "Personal Edition 3.0.7452";
-                    case 1176345423:
-                        return "Personal Edition 3.1.7466"; // 11.1.7466.0
-                    case 1184106698:
-                        return "Personal Edition 3.1.7556";
-                    case 1207280880:
-                        return "Personal Edition 4.0.8060"; // 2.3.7382.0
-                    case 1207280892:
-                        return "Personal Edition 4.0.8094"; // 11.2.8094.0
-                    case 1220904506:
-                        return "Personal Edition 4.0.8213"; // 2.3.7382.0
-                    case 1220904518:
-                        return "Personal Edition 4.0.8252"; // 12.0.8252.0
-                    case 1235490648:
-                        return "Personal Edition 4.0.8421"; // 3.1.8421.0
-                    case 1242049399:
-                        return "Personal Edition 4.0.8497"; // 12.1.8497.0
-                    case 1257193469:
-                        return "Personal Edition 4.0.8672"; // 3.1.8672.0, SI32LPE?
-                    default:
-                        return $"Personal Edition {assemblyVersion} (32-bit)";
-                }
+                    845061601 => "Personal Edition (32-bit)",// TODO: Find version
+                    868303343 => "Personal Edition (32-bit)",// TODO: Find version
+                    868304170 => "Personal Edition (32-bit)",// TODO: Find version
+                    906039079 => "Personal Edition 2.2.1260 (32-bit)",
+                    906040543 => "Personal Edition 2.2.1260 (32-bit)",
+                    908628435 => "Personal Edition 2.2.1285 (32-bit)",
+                    908628785 => "Personal Edition 2.2.1285 (32-bit)",
+                    956165981 => "Personal Edition 2.2.3063",
+                    956166038 => "Personal Edition 2.2.3063",
+                    1006353695 => "Personal Edition 2.2.4325",
+                    1006353714 => "Personal Edition 2.2.4325",// 8.1.0.0
+                    1076515698 => "Personal Edition 2.2.6028",
+                    1076515784 => "Personal Edition 2.2.6028",// 9.0.6028.0
+                    1092688561 => "Personal Edition 2.2.6224",
+                    1092688645 => "Personal Edition 2.2.6224",// 9.0.6224.0
+                    1125074095 => "Personal Edition 2.2.6604",
+                    1125074162 => "Personal Edition 2.2.6604",// 10.0.6604.0
+                    1130153399 => "Personal Edition 2.2.6663",
+                    1130153428 => "Personal Edition 2.2.6663",// 10.0.6663.0
+                    1149714176 => "Personal Edition 3.0.7158",
+                    1163137967 => "Personal Edition 3.0.7305",
+                    1163137994 => "Personal Edition 3.0.7313",// 11.0.7313.0
+                    1176345383 => "Personal Edition 3.0.7452",
+                    1176345423 => "Personal Edition 3.1.7466",// 11.1.7466.0
+                    1184106698 => "Personal Edition 3.1.7556",
+                    1207280880 => "Personal Edition 4.0.8060",// 2.3.7382.0
+                    1207280892 => "Personal Edition 4.0.8094",// 11.2.8094.0
+                    1220904506 => "Personal Edition 4.0.8213",// 2.3.7382.0
+                    1220904518 => "Personal Edition 4.0.8252",// 12.0.8252.0
+                    1235490648 => "Personal Edition 4.0.8421",// 3.1.8421.0
+                    1242049399 => "Personal Edition 4.0.8497",// 12.1.8497.0
+                    1257193469 => "Personal Edition 4.0.8672",// 3.1.8672.0, SI32LPE?
+                    _ => $"Personal Edition {assemblyVersion} (32-bit)",
+                };
             }
 
             // Software Installation
             else if (sfxFileName == "VW95SRE.SFX" || sfxFileName == "SI32E.SFX"
                 || sfxFileName == "SI32E.WZE")
             {
-                switch (sfxTimeDateStamp)
+                return sfxTimeDateStamp switch
                 {
-                    case 842636381:
-                        return "Software Installation 2.0 (32-bit)";
-                    case 865370800:
-                        return "Software Installation 2.1 RC2 (32-bit)";
-                    case 869059963:
-                        return "Software Installation 2.1 (32-bit)";
-                    case 893107697:
-                        return "Software Installation 2.2.1110 (32-bit)";
-                    case 952007369:
-                        return "Software Installation 2.2.3063";
-                    case 1006352634:
-                        return "Software Installation 2.2.4325"; // +Personal Edition?
-                    case 979049345:
-                        return "Software Installation 2.2.4403";
-                    case 1026227373:
-                        return "Software Installation 2.2.5196"; // +Personal Edition?
-                    case 1090582390:
-                        return "Software Installation 2.2.6202"; // +Personal Edition?
-                    case 1149714757:
-                        return "Software Installation 3.0.7158";
-                    case 1154357628:
-                        return "Software Installation 3.0.7212";
-                    case 1175234637:
-                        return "Software Installation 3.0.7454";
-                    case 1185211802:
-                        return "Software Installation 3.1.7556";
-                    case 1470410906:
-                        return "Software Installation 4.0.12218"; // 4.0.1221.0
-                    default:
-                        return $"Software Installation {assemblyVersion} (32-bit)";
-                }
+                    842636381 => "Software Installation 2.0 (32-bit)",
+                    865370800 => "Software Installation 2.1 RC2 (32-bit)",
+                    869059963 => "Software Installation 2.1 (32-bit)",
+                    893107697 => "Software Installation 2.2.1110 (32-bit)",
+                    952007369 => "Software Installation 2.2.3063",
+                    1006352634 => "Software Installation 2.2.4325",// +Personal Edition?
+                    979049345 => "Software Installation 2.2.4403",
+                    1026227373 => "Software Installation 2.2.5196",// +Personal Edition?
+                    1090582390 => "Software Installation 2.2.6202",// +Personal Edition?
+                    1149714757 => "Software Installation 3.0.7158",
+                    1154357628 => "Software Installation 3.0.7212",
+                    1175234637 => "Software Installation 3.0.7454",
+                    1185211802 => "Software Installation 3.1.7556",
+                    1470410906 => "Software Installation 4.0.12218",// 4.0.1221.0
+                    _ => $"Software Installation {assemblyVersion} (32-bit)",
+                };
             }
 
-            switch (sfxFileName)
+            return sfxFileName switch
             {
                 // Standard
-                case "VW95SE.SFX":
-                    return "Unknown Version (32-bit)"; // TODO: Find starting version
-                case "ST32E.SFX":
-                    return "Unknown Version (32-bit)"; // TODO: Find starting version
-                case "WZIPSE32.exe":
-                    return "Unknown Version (32-bit)"; // TODO: Find starting version
-                case "SI32LPG.SFX":
-                    return "Unknown Version (32-bit)"; // TODO: Find starting version
-                case "ST32E.WZE":
-                    return "Unknown Version (32-bit)"; // TODO: Find starting version
+                "VW95SE.SFX" => "Unknown Version (32-bit)",// TODO: Find starting version
+                "ST32E.SFX" => "Unknown Version (32-bit)",// TODO: Find starting version
+                "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
-                case "VW95LE.SFX":
-                    return "Unknown Version before Personal Edition Build 1285 (32-bit)";
-                case "PE32E.SFX":
-                    return "Unknown Version after Personal Edition Build 1285 (32-bit)";
-                case "wzsepe32.exe":
-                    return "Unknown Version Personal Edition (32-bit)"; // TODO: Find starting version
-                case "SI32PE.SFX":
-                    return "Unknown Version Personal Edition (32-bit)"; // TODO: Find starting version
-                case "SI32LPE.SFX":
-                    return "Unknown Version Personal Edition (32-bit)"; // TODO: Find starting version
+                "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
-                case "VW95SRE.SFX":
-                    return "Unknown Version before Software Installation 2.1 (32-bit)";
-                case "SI32E.SFX":
-                    return "Unknown Version after Software Installation 2.1 (32-bit)";
-                case "SI32E.WZE":
-                    return "Unknown Version Software Installation (32-bit)"; // TODO: Find starting version
-            }
-
-            return null;
+                "VW95SRE.SFX" => "Unknown Version before Software Installation 2.1 (32-bit)",
+                "SI32E.SFX" => "Unknown Version after Software Installation 2.1 (32-bit)",
+                "SI32E.WZE" => "Unknown Version Software Installation (32-bit)",// TODO: Find starting version
+                _ => null,
+            };
         }
     }
 }

BinaryObjectScanner/Packer/WiseInstaller.cs

@@ -1,20 +1,21 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
-using SabreTools.IO;
+using SabreTools.IO.Extensions;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 using SabreTools.Serialization.Wrappers;
-using Wise = WiseUnpacker.WiseUnpacker;
+using WiseUnpacker;
+using WiseUnpacker.EWISE;
 
 namespace BinaryObjectScanner.Packer
 {
     // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
-    public class WiseInstaller : IExtractable, 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)
@@ -30,17 +31,17 @@ namespace BinaryObjectScanner.Packer
             var neMatchSets = new List<ContentMatchSet>
             {
                 // WiseInst
-                new ContentMatchSet(new byte?[] { 0x57, 0x69, 0x73, 0x65, 0x49, 0x6E, 0x73, 0x74 }, "Wise Installation Wizard Module"),
+                new(new byte?[] { 0x57, 0x69, 0x73, 0x65, 0x49, 0x6E, 0x73, 0x74 }, "Wise Installation Wizard Module"),
 
                 // WiseMain
-                new ContentMatchSet(new byte?[] { 0x57, 0x69, 0x73, 0x65, 0x4D, 0x61, 0x69, 0x6E }, "Wise Installation Wizard Module"),
+                new(new byte?[] { 0x57, 0x69, 0x73, 0x65, 0x4D, 0x61, 0x69, 0x6E }, "Wise Installation Wizard Module"),
             };
 
             return MatchUtil.GetFirstMatch(file, data, neMatchSets, includeDebug);
         }
 
         /// <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;
@@ -57,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";
             }
 
@@ -65,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";
             }
 
@@ -73,38 +74,116 @@ namespace BinaryObjectScanner.Packer
         }
 
         /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
+        public bool Extract(string file, NewExecutable nex, string outDir, bool includeDebug)
         {
-            if (!File.Exists(file))
-                return null;
+            Directory.CreateDirectory(outDir);
 
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
             try
             {
-                // Try to parse as a New Executable
-                var nex = NewExecutable.Create(stream);
-                if (nex != null)
-                    return ExtractNewExecutable(nex, file, includeDebug);
-
-                // Try to parse as a Portable Executable
-                var pex = PortableExecutable.Create(stream);
-                if (pex != null)
-                    return ExtractPortableExecutable(pex, file, includeDebug);
-
-                return null;
+                return Extractor.ExtractTo(file, outDir);
             }
             catch (Exception ex)
             {
                 if (includeDebug) Console.WriteLine(ex);
-                return null;
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        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 false;
+
+                // Get the overlay data for easier reading
+                int overlayOffset = 0, dataStart = 0;
+                var overlayData = pex.OverlayData;
+                if (overlayData == null)
+                    return false;
+
+                // Skip over the additional DLL name, if we expect it
+                if (format.Dll)
+                {
+                    // Read the name length
+                    byte dllNameLength = overlayData.ReadByte(ref overlayOffset);
+                    dataStart++;
+
+                    // Read the name, if it exists
+                    if (dllNameLength != 0)
+                    {
+                        // Ignore the name for now
+                        _ = overlayData.ReadBytes(ref overlayOffset, dllNameLength);
+                        dataStart += dllNameLength;
+
+                        // Named DLLs also have a DLL length that we ignore
+                        _ = overlayData.ReadUInt32(ref overlayOffset);
+                        dataStart += 4;
+                    }
+                }
+
+                // Check if flags are consistent
+                if (!format.NoCrc)
+                {
+                    // Unlike WiseUnpacker, we ignore the flag value here
+                    _ = overlayData.ReadUInt32(ref overlayOffset);
+                }
+
+                // Ensure that we have an archive end
+                if (format.ArchiveEnd > 0)
+                {
+                    overlayOffset = (int)(dataStart + format.ArchiveEnd);
+                    int archiveEndLoaded = overlayData.ReadInt32(ref overlayOffset);
+                    if (archiveEndLoaded != 0)
+                        format.ArchiveEnd = archiveEndLoaded;
+                }
+
+                // Skip to the start of the archive
+                overlayOffset = (int)(dataStart + format.ArchiveStart);
+
+                // Skip over the initialization text, if we expect it
+                if (format.InitText)
+                {
+                    int initTextLength = overlayData.ReadByte(ref overlayOffset);
+                    _ = overlayData.ReadBytes(ref overlayOffset, initTextLength);
+                }
+
+                // Cache the current offset in the overlay as the "start of data"
+                int offsetReal = overlayOffset;
+
+                // 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
+
+                // Create the output directory
+                Directory.CreateDirectory(outDir);
+
+                // If we have PKZIP
+                if (pkzip)
+                {
+                    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
+                {
+                    return Extractor.ExtractTo(file, outDir);
+                }
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return false;
             }
         }
 
@@ -209,202 +288,5 @@ namespace BinaryObjectScanner.Packer
 
             return null;
         }
-
-        /// <summary>
-        /// Attempt to extract Wise data from a New Executable
-        /// </summary>
-        /// <param name="nex">New executable to check</param>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>True if it matches a known version, false otherwise</returns>
-        private string? ExtractNewExecutable(NewExecutable nex, string file, bool includeDebug)
-        {
-            string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-            Directory.CreateDirectory(tempPath);
-
-            try
-            {
-                // TODO: Try to find where the file data lives and how to get it
-                Wise unpacker = new Wise();
-                if (!unpacker.ExtractTo(file, tempPath))
-                {
-                    try
-                    {
-                        Directory.Delete(tempPath, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        if (includeDebug) Console.WriteLine(ex);
-                    }
-
-                    return null;
-                }
-            }
-            catch (Exception ex)
-            {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
-            }
-
-            return tempPath;
-        }
-
-        /// <summary>
-        /// Attempt to extract Wise data from a Portable Executable
-        /// </summary>
-        /// <param name="pex">Portable executable to check</param>
-        /// <param name="file">Path to the input file</param>
-        /// <param name="includeDebug">True to include debug data, false otherwise</param>
-        /// <returns>True if it matches a known version, false otherwise</returns>
-        private string? ExtractPortableExecutable(PortableExecutable pex, string file, bool includeDebug)
-        {
-            try
-            {
-                // Get the matching PE format
-                var format = GetPEFormat(pex);
-                if (format == null)
-                    return null;
-
-                // Get the overlay data for easier reading
-                int overlayOffset = 0, dataStart = 0;
-                var overlayData = pex.OverlayData;
-                if (overlayData == null)
-                    return null;
-
-                // Skip over the additional DLL name, if we expect it
-                if (format.Dll)
-                {
-                    // Read the name length
-                    byte dllNameLength = overlayData.ReadByte(ref overlayOffset);
-                    dataStart++;
-
-                    // Read the name, if it exists
-                    if (dllNameLength != 0)
-                    {
-                        // Ignore the name for now
-                        _ = overlayData.ReadBytes(ref overlayOffset, dllNameLength);
-                        dataStart += dllNameLength;
-
-                        // Named DLLs also have a DLL length that we ignore
-                        _ = overlayData.ReadUInt32(ref overlayOffset);
-                        dataStart += 4;
-                    }
-                }
-
-                // Check if flags are consistent
-                if (!format.NoCrc)
-                {
-                    // Unlike WiseUnpacker, we ignore the flag value here
-                    _ = overlayData.ReadUInt32(ref overlayOffset);
-                }
-
-                // Ensure that we have an archive end
-                if (format.ArchiveEnd > 0)
-                {
-                    overlayOffset = dataStart + format.ArchiveEnd;
-                    int archiveEndLoaded = overlayData.ReadInt32(ref overlayOffset);
-                    if (archiveEndLoaded != 0)
-                        format.ArchiveEnd = archiveEndLoaded;
-                }
-
-                // Skip to the start of the archive
-                overlayOffset = dataStart + format.ArchiveStart;
-
-                // Skip over the initialization text, if we expect it
-                if (format.InitText)
-                {
-                    int initTextLength = overlayData.ReadByte(ref overlayOffset);
-                    _ = overlayData.ReadBytes(ref overlayOffset, initTextLength);
-                }
-
-                // Cache the current offset in the overlay as the "start of data"
-                int offsetReal = overlayOffset;
-
-                // If the first entry is PKZIP, we assume it's an embedded zipfile
-                var magic = overlayData.ReadBytes(ref overlayOffset, 4); overlayOffset -= 4;
-                bool pkzip = magic?.StartsWith(new byte?[] { (byte)'P', (byte)'K' }) ?? false;
-
-                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-                Directory.CreateDirectory(tempPath);
-
-                // 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);
-                    }
-                }
-
-                // If we have DEFLATE -- TODO: Port implementation here or use DeflateStream
-                else
-                {
-                    Wise unpacker = new Wise();
-                    if (!unpacker.ExtractTo(file, tempPath))
-                    {
-                        try
-                        {
-                            Directory.Delete(tempPath, true);
-                        }
-                        catch (Exception ex)
-                        {
-                            if (includeDebug) Console.WriteLine(ex);
-                        }
-
-                        return null;
-                    }
-                }
-
-                return tempPath;
-            }
-            catch (Exception ex)
-            {
-                if (includeDebug) Console.WriteLine(ex);
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Class representing the properties of each recognized Wise installer format
-        /// </summary>
-        /// <see href="https://github.com/mnadareski/WiseUnpacker/blob/master/WiseUnpacker/FormatProperty.cs"/>
-        private class FormatProperty
-        {
-            /// <summary>
-            /// Offset to the executable data
-            /// </summary>
-            public int ExecutableOffset { get; set; }
-
-            /// <summary>
-            /// Indicates if this format includes a DLL at the start or not
-            /// </summary>
-            public bool Dll { get; set; }
-
-            /// <summary>
-            /// Offset within the data where the archive starts
-            /// </summary>
-            public int ArchiveStart { get; set; }
-
-            /// <summary>
-            /// Position in the archive head of the archive end
-            /// </summary>
-            public int ArchiveEnd { get; set; }
-
-            /// <summary>
-            /// Format includes initialization text
-            /// </summary>
-            public bool InitText { get; set; }
-
-            /// <summary>
-            /// Position of the filename within the data
-            /// </summary>
-            public int FilenamePosition { get; set; }
-
-            /// <summary>
-            /// Format does not include a CRC
-            /// </summary>
-            public bool NoCrc { get; set; }
-        }
     }
 }

BinaryObjectScanner/Packer/dotFuscator.cs

@@ -1,49 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
-using SabreTools.Serialization.Wrappers;
-
-namespace BinaryObjectScanner.Packer
-{
-    // TODO: Add extraction
-    public class dotFuscator : IExtractable, IPortableExecutableCheck
-    {
-        /// <inheritdoc/>
-        public string? CheckPortableExecutable(string file, PortableExecutable pex, bool includeDebug)
-        {
-            // Get the sections from the executable, if possible
-            var sections = pex.Model.SectionTable;
-            if (sections == null)
-                return null;
-
-            // Get the .text section strings, if they exist
-            var strs = pex.GetFirstSectionStrings(".text");
-            if (strs != null)
-            {
-                if (strs.Any(s => s.Contains("DotfuscatorAttribute")))
-                    return "dotFuscator";
-            }
-
-            return null;
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(string file, bool includeDebug)
-        {
-            if (!File.Exists(file))
-                return null;
-
-            using (var fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
-            {
-                return Extract(fs, file, includeDebug);
-            }
-        }
-
-        /// <inheritdoc/>
-        public string? Extract(Stream? stream, string file, bool includeDebug)
-        {
-            return null;
-        }
-    }
-}

BinaryObjectScanner/Progress.cs

@@ -1,4 +1,4 @@
-#if NET40
+#if NET20 || NET35 || NET40
 
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
@@ -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>
@@ -23,7 +33,7 @@ namespace System
     public class Progress<T> : IProgress<T> where T : EventArgs
     {
         /// <summary>The synchronization context captured upon construction.  This will never be null.</summary>
-        private readonly SynchronizationContext _synchronizationContext;
+        private readonly SynchronizationContext? _synchronizationContext;
         /// <summary>The handler specified to the constructor.  This may be null.</summary>
         private readonly Action<T>? _handler;
         /// <summary>A cached delegate used to post invocation to the synchronization context.</summary>
@@ -50,10 +60,7 @@ namespace System
         /// <exception cref="ArgumentNullException">The <paramref name="handler"/> is null (<see langword="Nothing" /> in Visual Basic).</exception>
         public Progress(Action<T> handler) : this()
         {
-            if (handler == null)
-                throw new ArgumentNullException(nameof(handler));
-
-            _handler = handler;
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
         }
 
         /// <summary>Raised for each reported progress value.</summary>
@@ -76,7 +83,7 @@ namespace System
             {
                 // Post the processing to the sync context.
                 // (If T is a value type, it will get boxed here.)
-                _synchronizationContext.Post(_invokeHandlers, value);
+                _synchronizationContext?.Post(_invokeHandlers, value);
             }
         }
 
@@ -103,7 +110,7 @@ namespace System
     internal static class ProgressStatics
     {
         /// <summary>A default synchronization context that targets the ThreadPool.</summary>
-        internal static readonly SynchronizationContext DefaultContext = new SynchronizationContext();
+        internal static readonly SynchronizationContext DefaultContext = new();
     }
 }
 

BinaryObjectScanner/Protection/ActiveMARK.cs

@@ -3,12 +3,13 @@ using System.Linq;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 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)
@@ -19,7 +20,7 @@ namespace BinaryObjectScanner.Protection
                 var contentMatchSets = new List<ContentMatchSet>
                 {
                     // " " + (char)0xC2 + (char)0x16 + (char)0x00 + (char)0xA8 + (char)0xC1 + (char)0x16 + (char)0x00 + (char)0xB8 + (char)0xC1 + (char)0x16 + (char)0x00 + (char)0x86 + (char)0xC8 + (char)0x16 + (char)0x00 + (char)0x9A + (char)0xC1 + (char)0x16 + (char)0x00 + (char)0x10 + (char)0xC2 + (char)0x16 + (char)0x00
-                    new ContentMatchSet(new byte?[]
+                    new(new byte?[]
                     {
                         0x20, 0xC2, 0x16, 0x00, 0xA8, 0xC1, 0x16, 0x00,
                         0xB8, 0xC1, 0x16, 0x00, 0x86, 0xC8, 0x16, 0x00,
@@ -34,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;
@@ -44,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";
                 }
@@ -102,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";
             }
 
@@ -110,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

@@ -1,8 +1,9 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -17,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;
@@ -51,7 +52,7 @@ namespace BinaryObjectScanner.Protection
                 {
                     // Found in "Asc001.dll", "Asc002.dll", "Asc003.dll", "Asc005.dll", "Asc006.exe", and "AscLM.cpl" (Redump entry 73521/IA item "Nova_HoyleCasino99USA").
                     // ÿÿÿÿ\\.\ASCLM
-                    new ContentMatchSet(new byte?[]
+                    new(new byte?[]
                     {
                         0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0x5C, 0x2E, 0x5C, 
                         0x41, 0x53, 0x43, 0x4C, 0x4D
@@ -59,7 +60,7 @@ namespace BinaryObjectScanner.Protection
                 };
 
                 var match = MatchUtil.GetFirstMatch(file, dataSectionRaw, matchers, includeDebug);
-                if (!string.IsNullOrWhiteSpace(match))
+                if (!string.IsNullOrEmpty(match))
                     return match;
             }
 
@@ -67,14 +68,14 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
                 // Found in Redump entry 73521/IA item "Nova_HoyleCasino99USA".
-                new PathMatchSet(new PathMatch("AscLM.cpl", useEndsWith: true), "AegiSoft License Manager"),
-                new PathMatchSet(new PathMatch("AscLM.vxd", useEndsWith: true), "AegiSoft License Manager"),
-                new PathMatchSet(new PathMatch("AscLMd.vxd", useEndsWith: true), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLM.cpl"), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLM.vxd"), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLMd.vxd"), "AegiSoft License Manager"),
 
                 // There are a few other files present, but the file names on their own may be too overmatching. Due to the small sample size, it's not sure if these files are always present together.
                 // These files are "Asc001.dll", "Asc002.dll", "Asc003.dll", "Asc005.dll", and "Asc006.exe" (Found in Redump entry 73521/IA item "Nova_HoyleCasino99USA").
@@ -89,9 +90,9 @@ namespace BinaryObjectScanner.Protection
             var matchers = new List<PathMatchSet>
             {
                 // Found in Redump entry 73521/IA item "Nova_HoyleCasino99USA".
-                new PathMatchSet(new PathMatch("AscLM.cpl", useEndsWith: true), "AegiSoft License Manager"),
-                new PathMatchSet(new PathMatch("AscLM.vxd", useEndsWith: true), "AegiSoft License Manager"),
-                new PathMatchSet(new PathMatch("AscLMd.vxd", useEndsWith: true), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLM.cpl"), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLM.vxd"), "AegiSoft License Manager"),
+                new(new FilePathMatch("AscLMd.vxd"), "AegiSoft License Manager"),
 
                 // There are a few other files present, but the file names on their own may be too overmatching. Due to the small sample size, it's not sure if these files are always present together.
                 // These files are "Asc001.dll", "Asc002.dll", "Asc003.dll", "Asc005.dll", and "Asc006.exe" (Found in Redump entry 73521/IA item "Nova_HoyleCasino99USA").

BinaryObjectScanner/Protection/AlphaDVD.cs

@@ -1,7 +1,7 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 
 namespace BinaryObjectScanner.Protection
 {
@@ -16,11 +16,11 @@ namespace BinaryObjectScanner.Protection
     public class AlphaDVD : IPathCheck
     {
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("PlayDVD.exe", useEndsWith: true), "Alpha-DVD (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("PlayDVD.exe"), "Alpha-DVD (Unconfirmed - Please report to us on Github)"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -31,7 +31,7 @@ namespace BinaryObjectScanner.Protection
         {
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("PlayDVD.exe", useEndsWith: true), "Alpha-DVD (Unconfirmed - Please report to us on Github"),
+                new(new FilePathMatch("PlayDVD.exe"), "Alpha-DVD (Unconfirmed - Please report to us on Github"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

BinaryObjectScanner/Protection/AlphaROM.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Interfaces;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -41,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.
@@ -58,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";
             }
 
@@ -69,7 +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.Exists(s => s.Contains("AlphaCheck.exe")))
+                    return "Alpha-ROM";
+                // Found in "Uninstall.exe" in Redump entry 115358.
+                if (strs.Exists(s => s.Contains("AlphaCheck.dat")))
                     return "Alpha-ROM";
             }
 
@@ -77,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

@@ -0,0 +1,60 @@
+using System;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Serialization.Wrappers;
+
+namespace BinaryObjectScanner.Protection
+{ 
+    /// <summary>
+    /// Armadillo was a license manager, packer, and DRM by "The Silicon Realm Toolworks": https://web.archive.org/web/20030203101931/http://www.siliconrealms.com/armadillo.shtml
+    /// They were later bought by Digital River, and updated their website: https://web.archive.org/web/20031203021152/http://www.siliconrealms.com/armadillo.shtml
+    /// A new updated version named "SoftwarePassport" was released: https://web.archive.org/web/20040423044529/http://siliconrealms.com/softwarepassport/popup.shtml
+    /// Later copy of the website, with SoftwarePassport being named instead of Armadillo: https://web.archive.org/web/20040804032608/http://www.siliconrealms.com/armadillo.shtml
+    /// It appears as though both Armadillo and SoftwarePassport were being released at the same time, possibly with Armadillo acting as the core component and SoftwarePassport being supplementary: https://web.archive.org/web/20050619013312/http://siliconrealms.com/srt-news.shtml
+    /// Digital River itself also advertised Armadillo at first: https://web.archive.org/web/20040116043029/http://www.digitalriver.com:80/corporate/solutions06.shtml
+    /// But then only advertised SoftwarePassport once it was released: https://web.archive.org/web/20040604065907/http://www.digitalriver.com/corporate/solutions06.shtml
+    /// </summary>
+    
+    // TODO: Add extraction
+    // TODO: Add version checking, if possible
+    // https://raw.githubusercontent.com/wolfram77web/app-peid/master/userdb.txt
+    
+    public class Armadillo : IExtractableExecutable<PortableExecutable>
+    {
+        /// <inheritdoc/>
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
+        {
+            // Get the sections from the executable, if possible
+            var sections = pex.Model.SectionTable;
+            if (sections == null)
+                return null;
+
+            // Get the .nicode section, if it exists
+            bool nicodeSection = pex.ContainsSection(".nicode", exact: true);
+            if (nicodeSection)
+                return "Armadillo";
+
+            // Loop through all "extension" sections -- usually .data1 or .text1
+            if (pex.SectionNames != null)
+            {
+                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.Exists(s => s.Contains("ARMDEBUG")))
+                            return "Armadillo";
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public bool Extract(string file, PortableExecutable pex, string outDir, bool includeDebug)
+        {
+            return false;
+        }
+    }
+}

BinaryObjectScanner/Protection/Bitpool.cs

@@ -1,7 +1,7 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 
 namespace BinaryObjectScanner.Protection
 {
@@ -13,25 +13,25 @@ namespace BinaryObjectScanner.Protection
     public class Bitpool : IPathCheck
     {
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("bitpool.rsc", useEndsWith: true), "Bitpool"),
-                new PathMatchSet(new FilePathMatch("CD.IDX"), "Bitpool"),
+                new(new FilePathMatch("bitpool.rsc"), "Bitpool"),
+                new(new FilePathMatch("CD.IDX"), "Bitpool"),
 
                 // Completely empty file present on multiple discs with Bitpool (Redump entries 52626 and 50229).
-                new PathMatchSet(new PathMatch("LEADOUT.OFS", useEndsWith: true), "Bitpool"),
+                new(new FilePathMatch("LEADOUT.OFS"), "Bitpool"),
 
                 // A set of 4 identically sized (within the same game, not between games), corrupted/padded files present in several games (Redump entries 31782 and 35476).
                 // Both examples with only having the first letter uppercase and as the whole file name being uppercase have been seen.
-                new PathMatchSet(new List<PathMatch>
-                {
+                new(
+                [
                     new FilePathMatch("Crc_a"),
                     new FilePathMatch("Crc_b"),
                     new FilePathMatch("Crc_c"),
                     new FilePathMatch("Crc_d"),
-                }, "Bitpool"),
+                ], "Bitpool"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -42,11 +42,11 @@ namespace BinaryObjectScanner.Protection
         {
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("bitpool.rsc", useEndsWith: true), "Bitpool"),
-                new PathMatchSet(new FilePathMatch("CD.IDX"), "Bitpool"),
+                new(new FilePathMatch("bitpool.rsc"), "Bitpool"),
+                new(new FilePathMatch("CD.IDX"), "Bitpool"),
 
                 // Completely empty file present on multiple discs with Bitpool (Redump entries 52626 and 50229).
-                new PathMatchSet(new PathMatch("LEADOUT.OFS", useEndsWith: true), "Bitpool"),
+                new(new FilePathMatch("LEADOUT.OFS"), "Bitpool"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

BinaryObjectScanner/Protection/ByteShield.cs

@@ -1,8 +1,8 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -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";
             }
 
@@ -130,14 +130,14 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             // TODO: Investigate reference to "bbz650.tmp" in "Byteshield.dll" (Redump entry 6236)
             // Files with the ".bbz" extension are associated with ByteShield, but the extenstion is known to be used in other places as well.
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("Byteshield.dll", useEndsWith: true), "ByteShield Component Module"),
-                new PathMatchSet(new PathMatch("Byteshield.ini", useEndsWith: true), "ByteShield"),
+                new(new FilePathMatch("Byteshield.dll"), "ByteShield Component Module"),
+                new(new FilePathMatch("Byteshield.ini"), "ByteShield"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -150,8 +150,8 @@ namespace BinaryObjectScanner.Protection
             // Files with the ".bbz" extension are associated with ByteShield, but the extenstion is known to be used in other places as well.
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("Byteshield.dll", useEndsWith: true), "ByteShield Component Module"),
-                new PathMatchSet(new PathMatch("Byteshield.ini", useEndsWith: true), "ByteShield"),
+                new(new FilePathMatch("Byteshield.dll"), "ByteShield Component Module"),
+                new(new FilePathMatch("Byteshield.ini"), "ByteShield"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

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

@@ -1,11 +1,11 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
-using SabreTools.Models.PortableExecutable;
+using SabreTools.Matching.Content;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -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/>
@@ -76,14 +76,14 @@ namespace BinaryObjectScanner.Protection
                 {
                     // TODO: Remove from here once it's confirmed that no PE executables contain this string
                     // CD-Cops,  ver. 
-                    new ContentMatchSet(new byte?[]
+                    new(new byte?[]
                     {
                         0x43, 0x44, 0x2D, 0x43, 0x6F, 0x70, 0x73, 0x2C,
                         0x20, 0x20, 0x76, 0x65, 0x72, 0x2E, 0x20
                     }, GetVersion, "CD-Cops (Unconfirmed - Please report to us on Github)"),
 
                     // // DVD-Cops,  ver. 
-                    new ContentMatchSet(new byte?[]
+                    new(new byte?[]
                     {
                         0x44, 0x56, 0x44, 0x2D, 0x43, 0x6F, 0x70, 0x73,
                         0x2C, 0x20, 0x20, 0x76, 0x65, 0x72, 0x2E, 0x20
@@ -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();
@@ -109,7 +109,7 @@ namespace BinaryObjectScanner.Protection
             {
                 // CD-Cops,  ver. 
                 // Found in "h3blade.exe" in Redump entry 85077.
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x43, 0x44, 0x2D, 0x43, 0x6F, 0x70, 0x73, 0x2C,
                     0x20, 0x20, 0x76, 0x65, 0x72, 0x2E, 0x20
@@ -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;
@@ -155,14 +155,14 @@ namespace BinaryObjectScanner.Protection
             {
                 // WEBCOPS
                 // Found in "HyperBowl.C_S" in https://web.archive.org/web/20120616074941/http://icm.games.tucows.com/files2/HyperDemo-109a.exe.
-                new ContentMatchSet(new byte?[]
+                new(new byte?[]
                 {
                     0x57, 0x45, 0x42, 0x43, 0x4F, 0x50, 0x53
                 }, "WEB-Cops")
             };
 
                 var match = MatchUtil.GetFirstMatch(file, pex.StubExecutableData, matchers, includeDebug);
-                if (!string.IsNullOrWhiteSpace(match))
+                if (!string.IsNullOrEmpty(match))
                     return match;
             }
 
@@ -182,7 +182,7 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             // TODO: Original had "CDCOPS.DLL" required and all the rest in a combined OR
             var matchers = new List<PathMatchSet>
@@ -191,12 +191,12 @@ namespace BinaryObjectScanner.Protection
                 // Presumably used to increase the amount of data written to the disc to allow DPM checking to be used for the protection. It's unknown if this file is used on any other protected discs.
 
                 // Found in Redump entry 84517.
-                new PathMatchSet(new PathMatch("CDCOPS.DLL", useEndsWith: true), "CD-Cops"),
-                new PathMatchSet(new PathMatch(".W_X", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
-                new PathMatchSet(new PathMatch(".QZ_", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
+                new(new FilePathMatch("CDCOPS.DLL"), "CD-Cops"),
+                new(new PathMatch(".W_X", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
+                new(new PathMatch(".QZ_", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
 
-                new PathMatchSet(new PathMatch(".GZ_", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch(".Qz", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
+                new(new PathMatch(".GZ_", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
+                new(new PathMatch(".Qz", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -211,12 +211,12 @@ namespace BinaryObjectScanner.Protection
                 // Presumably used to increase the amount of data written to the disc to allow DPM checking to be used for the protection. It's unknown if this file is used on any other protected discs.
 
                 // Found in Redump entry 84517.
-                new PathMatchSet(new PathMatch("CDCOPS.DLL", useEndsWith: true), "CD-Cops"),
-                new PathMatchSet(new PathMatch(".W_X", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
-                new PathMatchSet(new PathMatch(".QZ_", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
+                new(new FilePathMatch("CDCOPS.DLL"), "CD-Cops"),
+                new(new PathMatch(".W_X", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
+                new(new PathMatch(".QZ_", matchExact: true, useEndsWith: true), "CD/DVD-Cops"),
 
-                new PathMatchSet(new PathMatch(".GZ_", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch(".Qz", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
+                new(new PathMatch(".GZ_", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
+                new(new PathMatch(".Qz", matchExact: true, useEndsWith: true), "CD-Cops (Unconfirmed - Please report to us on Github)"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);
@@ -228,13 +228,10 @@ namespace BinaryObjectScanner.Protection
             if (fileContent == null)
                 return null;
 
-#if 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,9 +1,8 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -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";
             }
@@ -55,12 +54,12 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
                 // Found in Redump entry 97142.
-                new PathMatchSet(new PathMatch("cdguard.dll", useEndsWith: true), "CD-Guard Copy Protection System"),
+                new(new FilePathMatch("cdguard.dll"), "CD-Guard Copy Protection System"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -72,7 +71,7 @@ namespace BinaryObjectScanner.Protection
             var matchers = new List<PathMatchSet>
             {
                 // Found in Redump entry 97142.
-                new PathMatchSet(new PathMatch("cdguard.dll", useEndsWith: true), "CD-Guard Copy Protection System"),
+                new(new FilePathMatch("cdguard.dll"), "CD-Guard Copy Protection System"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

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

@@ -1,7 +1,8 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -24,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;
@@ -43,7 +44,7 @@ namespace BinaryObjectScanner.Protection
                     // Found in game executables protected with CD-Lock (Redump entries 24287 and 31615).
                     // TODO: Check for possible false postives (Redump entry 97942).
                     // 2 + (char)0xF2 + (char)0x02 + (char)0x82 + (char)0xC3 + (char)0xBC + (char)0x0B + $ + (char)0x99 + (char)0xAD + 'C + (char)0xE4 + (char)0x9D + st + (char)0x99 + (char)0xFA + 2$ + (char)0x9D + )4 + (char)0xFF + t
-                    new ContentMatchSet(new byte?[]
+                    new(new byte?[]
                     {
                         0x32, 0xF2, 0x02, 0x82, 0xC3, 0xBC, 0x0B, 0x24,
                         0x99, 0xAD, 0x27, 0x43, 0xE4, 0x9D, 0x73, 0x74,
@@ -53,7 +54,7 @@ namespace BinaryObjectScanner.Protection
                 };
 
                 var match = MatchUtil.GetFirstMatch(file, dataSectionRaw, matchers, includeDebug);
-                if (!string.IsNullOrWhiteSpace(match))
+                if (!string.IsNullOrEmpty(match))
                     return match;
             }
 
@@ -61,14 +62,14 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
                 // TODO: Determine if there's any consistency in the naming of the additional AFP files.
 
                 // Found in every confirmed sample of CD-Lock, generally (but not always) appears to include markers relating to the additional AFP files present (Redump entries 24287 and 31615). 
-                new PathMatchSet(new PathMatch("CONFIG.AFP", useEndsWith: true), "CD-Lock"),
+                new(new FilePathMatch("CONFIG.AFP"), "CD-Lock"),
 
                 // There is also a "$$$$$$$$.$$$" file present on some discs, but it isn't known if this is directly related to CD-Lock (Redump entries 37788 and 43221).
             };
@@ -84,7 +85,7 @@ namespace BinaryObjectScanner.Protection
                 // TODO: Determine if there's any consistency in the naming of the additional AFP files.
 
                 // Found in every confirmed sample of CD-Lock, generally (but not always) appears to include markers relating to the additional AFP files present (Redump entries 24287 and 31615).
-                new PathMatchSet(new PathMatch("CONFIG.AFP", useEndsWith: true), "CD-Lock"),
+                new(new FilePathMatch("CONFIG.AFP"), "CD-Lock"),
 
                 // There is also a "$$$$$$$$.$$$" file present on some discs, but it isn't known if this is directly related to CD-Lock (Redump entries 37788 and 43221).
             };

BinaryObjectScanner/Protection/CDProtector.cs

@@ -1,7 +1,7 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 
 namespace BinaryObjectScanner.Protection
 {
@@ -17,7 +17,7 @@ namespace BinaryObjectScanner.Protection
     public class CDProtector : IPathCheck
     {
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
@@ -26,13 +26,13 @@ namespace BinaryObjectScanner.Protection
                 // "_cdp32.dat" is actually an archive that contains the original executable.
                 // Another EXE is created, with the name of the original executable. I'm not sure what this executable does, but it appears to be compressed with NeoLite.
                 // TODO: Invesitage if this EXE itself can be detected in any way.
-                new PathMatchSet(new PathMatch("_cdp16.dat", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp16.dll", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp32.dat", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp32.dll", useEndsWith: true), "CD-Protector"),
+                new(new FilePathMatch("_cdp16.dat"), "CD-Protector"),
+                new(new FilePathMatch("_cdp16.dll"), "CD-Protector"),
+                new(new FilePathMatch("_cdp32.dat"), "CD-Protector"),
+                new(new FilePathMatch("_cdp32.dll"), "CD-Protector"),
 
                 // This is the "Phantom Trax" file generated by CD-Protector, intended to be burned to a protected CD as an audio track.
-                new PathMatchSet(new PathMatch("Track#1 - Track#2 Cd-Protector.wav", useEndsWith: true), "CD-Protector"),
+                new(new FilePathMatch("Track#1 - Track#2 Cd-Protector.wav"), "CD-Protector"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -48,13 +48,13 @@ namespace BinaryObjectScanner.Protection
                 // "_cdp32.dat" is actually an archive that contains the original executable.
                 // Another EXE is created, with the name of the original executable. I'm not sure what this executable does, but it appears to be compressed with NeoLite.
                 // TODO: Invesitage if this EXE itself can be detected in any way.
-                new PathMatchSet(new PathMatch("_cdp16.dat", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp16.dll", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp32.dat", useEndsWith: true), "CD-Protector"),
-                new PathMatchSet(new PathMatch("_cdp32.dll", useEndsWith: true), "CD-Protector"),
+                new(new FilePathMatch("_cdp16.dat"), "CD-Protector"),
+                new(new FilePathMatch("_cdp16.dll"), "CD-Protector"),
+                new(new FilePathMatch("_cdp32.dat"), "CD-Protector"),
+                new(new FilePathMatch("_cdp32.dll"), "CD-Protector"),
 
                 // This is the "Phantom Trax" file generated by CD-Protector, intended to be burned to a protected CD as an audio track.
-                new PathMatchSet(new PathMatch("Track#1 - Track#2 Cd-Protector.wav", useEndsWith: true), "CD-Protector"),
+                new(new FilePathMatch("Track#1 - Track#2 Cd-Protector.wav"), "CD-Protector"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

BinaryObjectScanner/Protection/CDSHiELDSE.cs

@@ -1,14 +1,12 @@
-using System.Collections.Generic;
-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;
@@ -28,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/CDX.cs

@@ -1,21 +1,25 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 
 namespace BinaryObjectScanner.Protection
 {
+    // Nothing is currently known about this DRM. One program may possibly have included it, as it has been listed as including these files in the installion directory (https://www.advanceduninstaller.com/Visit-Gallery-2-90896afd3151ed9660dddc23b892863f-application.htm).
+    // Unfortunately, this program and developer are so obscure, I'm not able to find any relevant further information on them whatsoever.
+    // The only source of valuable information currently known is a forum post about a user attempting to crack this DRM (https://forum.p30world.com/showthread.php?t=413264).
+    // Every attachment, upload, or photo from the forum thread are offline and unarchived.
     public class CDX : IPathCheck
     {
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             // TODO: Verify if these are OR or AND
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("CHKCDX16.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch("CHKCDX32.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch("CHKCDXNT.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDX16.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDX32.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDXNT.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -26,9 +30,9 @@ namespace BinaryObjectScanner.Protection
         {
             var matchers = new List<PathMatchSet>
             {
-                new PathMatchSet(new PathMatch("CHKCDX16.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch("CHKCDX32.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
-                new PathMatchSet(new PathMatch("CHKCDXNT.DLL", useEndsWith: true), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDX16.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDX32.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
+                new(new FilePathMatch("CHKCDXNT.DLL"), "CD-X (Unconfirmed - Please report to us on Github)"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

BinaryObjectScanner/Protection/CactusDataShield.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
-using System.Linq;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Content;
 
 namespace BinaryObjectScanner.Protection
 {
@@ -17,14 +17,13 @@ namespace BinaryObjectScanner.Protection
                 var contentMatchSets = new List<ContentMatchSet>
                 {
                     // CDSPlayer
-                    new ContentMatchSet(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 ContentMatchSet(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

@@ -1,8 +1,8 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.Matching;
+using SabreTools.Matching.Paths;
 using SabreTools.Serialization.Wrappers;
 
 namespace BinaryObjectScanner.Protection
@@ -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;
@@ -53,13 +53,13 @@ namespace BinaryObjectScanner.Protection
         }
 
         /// <inheritdoc/>
-        public ConcurrentQueue<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
         {
             var matchers = new List<PathMatchSet>
             {
                 // Seems likely to be present in most, if not all discs protected with Cenega ProtectDVD, but unable to confirm due to only having a small sample size.
                 // Found in Redump entry 31422 and IA item "speed-pack".
-                new PathMatchSet(new PathMatch("cenega.dll", useEndsWith: true), "Cenega ProtectDVD"),
+                new(new FilePathMatch("cenega.dll"), "Cenega ProtectDVD"),
             };
 
             return MatchUtil.GetAllMatches(files, matchers, any: true);
@@ -72,7 +72,7 @@ namespace BinaryObjectScanner.Protection
             {
                 // Seems likely to be present in most, if not all discs protected with Cenega ProtectDVD, but unable to confirm due to only having a small sample size.
                 // Found in Redump entry 31422 and IA item "speed-pack".
-                new PathMatchSet(new PathMatch("cenega.dll", useEndsWith: true), "Cenega ProtectDVD"),
+                new(new FilePathMatch("cenega.dll"), "Cenega ProtectDVD"),
             };
 
             return MatchUtil.GetFirstMatch(path, matchers, any: true);

BinaryObjectScanner/Protection/Channelware.cs

@@ -0,0 +1,115 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Matching;
+using SabreTools.Matching.Paths;
+using SabreTools.Serialization.Wrappers;
+
+namespace BinaryObjectScanner.Protection
+{
+    /// <summary>
+    /// Channelware was an online activation DRM.
+    /// 
+    /// Official websites:
+    /// 
+    /// https://web.archive.org/web/19980212121046/http://www.channelware.com/index.html
+    /// https://web.archive.org/web/20021002225705/http://cwsw.com/Home/default.asp
+    /// https://web.archive.org/web/20040101180929/http://www.netactive.com/Home/
+    /// 
+    /// TODO:
+    /// 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 : IExecutableCheck<PortableExecutable>, IPathCheck
+    {
+        /// <inheritdoc/>
+        public string? CheckExecutable(string file, PortableExecutable pex, bool includeDebug)
+        {
+            // Get the sections from the executable, if possible
+            var sections = pex.Model.SectionTable;
+            if (sections == null)
+                return null;
+
+            // Found in "AbeWincw.dll" in Redump entry 116358 and in "TOYSGMcw.dll" in the "TOYSTORY" installation folder from Redump entry 12354.
+            var name = pex.ProductName;
+            if (name?.Equals("ChannelWare Utilities") == true)
+                return "Channelware";
+
+            // Found in "cwbrowse.exe" in the "Channelware" folder installed from Redump entry 12354.
+            if (name?.Equals("Channelware Browser Launcher") == true)
+                return "Channelware";
+
+            // Found in "cwuninst.exe" in the "Channelware" folder installed from Redump entry 12354.
+            if (name?.Equals("Channelware Launcher Uninstall Application") == true)
+                return "Channelware";
+
+            // Found in "cwbrowse.exe" in the "Channelware\CWBrowse" folder installed from Redump entry 116358.
+            if (name?.Equals("Channelware Authorization Server Browser Launcher") == true)
+                return "Channelware";
+
+            name = pex.FileDescription;
+            // Found in "cwuninst.exe" in the "Channelware" folder installed from Redump entry 12354.
+            if (name?.Equals("Channelware Launcher Uninstall") == true)
+                return "Channelware";
+
+            name = pex.LegalTrademarks;
+            // Found in "CWAuto.dll" and "Upgrader.exe" in the "TOYSTORY" installation folder from Redump entry 12354.
+            if (name?.Equals("Channelware") == true)
+                return "Channelware";
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public IEnumerable<string> CheckDirectoryPath(string path, IEnumerable<string>? files)
+        {
+            var matchers = new List<PathMatchSet>
+            {
+                // Found in Redump entries 12354 and 116358.
+                new(new FilePathMatch("cwlaunch.hlp"), "Channelware"),
+
+                // Found in the "Channelware\CWBrowse" folder installed from Redump entry 116358, and in the "Channelware" folder installed from Redump entry 12354.
+                new(new FilePathMatch("cwbrowse.exe"), "Channelware"),
+
+                // Found in the "Channelware" folder installed from Redump entry 12354.
+                new(new FilePathMatch("cwuninst.exe"), "Channelware"),
+                new(new FilePathMatch("chanwr.ini"), "Channelware"),
+                new(new FilePathMatch("CWAuto.dll"), "Channelware"),
+
+                // Found in Redump entry 116358.
+                new(Path.Combine("CWare", "install.exe"), "Channelware"),
+
+                // Found in Redump entry 12354.
+                new(Path.Combine("cware", "Install.exe"), "Channelware"),
+            };
+
+            return MatchUtil.GetAllMatches(files, matchers, any: true);
+        }
+
+        /// <inheritdoc/>
+        public string? CheckFilePath(string path)
+        {
+            var matchers = new List<PathMatchSet>
+            {
+                // Found in Redump entries 12354 and 116358.
+                new(new FilePathMatch("cwlaunch.hlp"), "Channelware"),
+
+                // Found in the "Channelware\CWBrowse" folder installed from Redump entry 116358, and in the "Channelware" folder installed from Redump entry 12354.
+                new(new FilePathMatch("cwbrowse.exe"), "Channelware"),
+
+                // Found in the "Channelware" folder installed from Redump entry 12354.
+                new(new FilePathMatch("cwuninst.exe"), "Channelware"),
+                new(new FilePathMatch("chanwr.ini"), "Channelware"),
+                new(new FilePathMatch("CWAuto.dll"), "Channelware"),
+
+                // Found in Redump entry 116358.
+                new(Path.Combine("CWare", "install.exe"), "Channelware"),
+
+                // Found in Redump entry 12354.
+                new(Path.Combine("cware", "Install.exe"), "Channelware"),
+            };
+
+            return MatchUtil.GetFirstMatch(path, matchers, any: true);
+        }
+    }
+}