Move extractable file types to new library

BinaryObjectScanner.FileType/BFPK.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// BFPK custom archive format
+    /// </summary>
+    public class BFPK : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.BFPK bfpk = 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);
+
+                // Extract all files
+                bfpk.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/BSP.cs

@@ -0,0 +1,51 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Half-Life Level
+    /// </summary>
+    public class BSP : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.BSP bsp = 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);
+
+                // Loop through and extract all files
+                bsp.ExtractAllLumps(tempPath);
+                bsp.ExtractAllTextures(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/BZip2.cs

@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.BZip2;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// bzip2 archive
+    /// </summary>
+    public class BZip2 : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                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);
+                    }
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/BinaryObjectScanner.FileType.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>net48;net6.0;net7.0</TargetFrameworks>
@@ -20,4 +20,15 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\BinaryObjectScanner.Interfaces\BinaryObjectScanner.Interfaces.csproj" />
+    <ProjectReference Include="..\BinaryObjectScanner.Wrappers\BinaryObjectScanner.Wrappers.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="OpenMcdf" Version="2.2.1.12" />
+    <PackageReference Include="SharpCompress" Version="0.32.2" />
+    <PackageReference Include="UnshieldSharp" Version="1.6.9" />
+  </ItemGroup>
+
 </Project>

BinaryObjectScanner.FileType/CFB.cs

@@ -0,0 +1,149 @@
+using System;
+using System.IO;
+using System.Text;
+using BinaryObjectScanner.Interfaces;
+using OpenMcdf;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Compound File Binary
+    /// </summary>
+    public class CFB : IExtractable
+    {
+        /// <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)
+        {
+            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))
+                {
+                    msi.RootStorage.VisitEntries((e) =>
+                    {
+                        try
+                        {
+                            if (!e.IsStream)
+                                return;
+
+                            var str = msi.RootStorage.GetStream(e.Name);
+                            if (str == null)
+                                return;
+
+                            byte[] strData = str.GetData();
+                            if (strData == null)
+                                return;
+
+                            string decoded = DecodeStreamName(e.Name).TrimEnd('\0');
+                            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);
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            if (includeDebug) Console.WriteLine(ex);
+                        }
+                    }, recursive: true);
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+
+        /// <remarks>Adapted from LibMSI</remarks>
+        public static string DecodeStreamName(string input)
+        {
+            if (input == null)
+                return null;
+
+            int count = 0;
+            byte[] inputBytes = Encoding.UTF8.GetBytes(input);
+            int p = 0; // inputBytes[0]
+
+            byte[] output = new byte[inputBytes.Length + 1];
+            int q = 0; // output[0]
+            while (p < inputBytes.Length && inputBytes[p] != 0)
+            {
+                int ch = inputBytes[p];
+                if ((ch == 0xe3 && inputBytes[p + 1] >= 0xa0) || (ch == 0xe4 && inputBytes[p + 1] < 0xa0))
+                {
+                    // UTF-8 encoding of 0x3800..0x47ff. 
+                    output[q++] = (byte)Mime2Utf(inputBytes[p + 2] & 0x7f);
+                    output[q++] = (byte)Mime2Utf(inputBytes[p + 1] ^ 0xa0);
+                    p += 3;
+                    count += 2;
+                    continue;
+                }
+
+                if (ch == 0xe4 && inputBytes[p + 1] == 0xa0)
+                {
+                    // UTF-8 encoding of 0x4800..0x483f.
+                    output[q++] = (byte)Mime2Utf(inputBytes[p + 2] & 0x7f);
+                    p += 3;
+                    count++;
+                    continue;
+                }
+
+                output[q++] = inputBytes[p++];
+                if (ch >= 0xc1)
+                    output[q++] = inputBytes[p++];
+                if (ch >= 0xe0)
+                    output[q++] = inputBytes[p++];
+                if (ch >= 0xf0)
+                    output[q++] = inputBytes[p++];
+
+                count++;
+            }
+
+            output[q] = 0;
+            return Encoding.ASCII.GetString(output);
+        }
+
+        /// <remarks>Adapted from LibMSI</remarks>
+        private static int Mime2Utf(int x)
+        {
+            if (x < 10)
+                return x + '0';
+            if (x < (10 + 26))
+                return x - 10 + 'A';
+            if (x < (10 + 26 + 26))
+                return x - 10 - 26 + 'a';
+            if (x == (10 + 26 + 26))
+                return '.';
+            return '_';
+        }
+    }
+}

BinaryObjectScanner.FileType/GCF.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Half-Life Game Cache File
+    /// </summary>
+    public class GCF : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.GCF gcf = 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);
+
+                // Loop through and extract all files
+                gcf.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/GZIP.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Archives;
+using SharpCompress.Archives.GZip;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// gzip archive
+    /// </summary>
+    public class GZIP : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (GZipArchive zipFile = GZipArchive.Open(stream))
+                {
+                    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;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/InstallShieldArchiveV3.cs

@@ -0,0 +1,68 @@
+using System;
+using System.IO;
+using System.Linq;
+using BinaryObjectScanner.Interfaces;
+using UnshieldSharp.Archive;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// InstallShield archive v3
+    /// </summary>
+    public class InstallShieldArchiveV3 : IExtractable
+    {
+        /// <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)
+        {
+            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))
+                {
+                    try
+                    {
+                        string tempFile = Path.Combine(tempPath, cfile.FullPath);
+                        if (!Directory.Exists(Path.GetDirectoryName(tempFile)))
+                            Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
+
+                        (byte[] fileContents, string error) = archive.Extract(cfile.FullPath);
+                        if (!string.IsNullOrWhiteSpace(error))
+                            continue;
+
+                        using (FileStream fs = File.OpenWrite(tempFile))
+                        {
+                            fs.Write(fileContents, 0, fileContents.Length);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
+                    }
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/InstallShieldCAB.cs

@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+using BinaryObjectScanner.Interfaces;
+using UnshieldSharp.Cabinet;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// InstallShield cabinet file
+    /// </summary>
+    public class InstallShieldCAB : IExtractable
+    {
+        /// <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)
+        {
+            // Get the name of the first cabinet file or header
+            string directory = Path.GetDirectoryName(file);
+            string noExtension = Path.GetFileNameWithoutExtension(file);
+            string filenamePattern = Path.Combine(directory, noExtension);
+            filenamePattern = new Regex(@"\d+$").Replace(filenamePattern, string.Empty);
+
+            bool cabinetHeaderExists = File.Exists(Path.Combine(directory, filenamePattern + "1.hdr"));
+            bool shouldScanCabinet = cabinetHeaderExists
+                ? file.Equals(Path.Combine(directory, filenamePattern + "1.hdr"), StringComparison.OrdinalIgnoreCase)
+                : file.Equals(Path.Combine(directory, filenamePattern + "1.cab"), StringComparison.OrdinalIgnoreCase);
+
+            // If we have anything but the first file
+            if (!shouldScanCabinet)
+                return null;
+
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                InstallShieldCabinet cabfile = InstallShieldCabinet.Open(file);
+                for (int i = 0; i < cabfile.FileCount; i++)
+                {
+                    try
+                    {
+                        // Check if the file is valid first
+                        if (!cabfile.FileIsValid(i))
+                            continue;
+
+                        string tempFile;
+                        try
+                        {
+                            string filename = cabfile.FileName(i);
+                            tempFile = Path.Combine(tempPath, filename);
+                        }
+                        catch
+                        {
+                            tempFile = Path.Combine(tempPath, $"BAD_FILENAME{i}");
+                        }
+
+                        cabfile.FileSave(i, tempFile);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (includeDebug) Console.WriteLine(ex);
+                    }
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/MicrosoftCAB.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using BinaryObjectScanner.Wrappers;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Microsoft cabinet file
+    /// </summary>
+    /// <remarks>Specification available at <see href="http://download.microsoft.com/download/5/0/1/501ED102-E53F-4CE0-AA6B-B0F93629DDC6/Exchange/%5BMS-CAB%5D.pdf"/></remarks>
+    /// <see href="https://github.com/wine-mirror/wine/tree/master/dlls/cabinet"/>
+    public class MicrosoftCAB : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Open the cab file
+                var cabFile = MicrosoftCabinet.Create(stream);
+                if (cabFile == null)
+                    return null;
+
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                // If entry extraction fails
+                bool success = cabFile.ExtractAll(tempPath);
+                if (!success)
+                    return null;
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/MicrosoftLZ.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Compression;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Microsoft LZ-compressed Files (LZ32)
+    /// </summary>
+    /// <remarks>This is treated like an archive type due to the packing style</remarks>
+    public class MicrosoftLZ : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                byte[] data = LZ.Decompress(stream);
+
+                // Create the temp filename
+                string tempFile = "temp.bin";
+                if (!string.IsNullOrEmpty(file))
+                {
+                    string expandedFilePath = LZ.GetExpandedName(file, out _);
+                    tempFile = Path.GetFileName(expandedFilePath).TrimEnd('\0');
+                    if (tempFile.EndsWith(".ex"))
+                        tempFile += "e";
+                    else if (tempFile.EndsWith(".dl"))
+                        tempFile += "l";
+                }
+
+                tempFile = Path.Combine(tempPath, tempFile);
+
+                // 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);
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/PAK.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Half-Life Package File
+    /// </summary>
+    public class PAK : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.PAK pak = 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);
+
+                // Loop through and extract all files
+                pak.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/PFF.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// NovaLogic Game Archive Format
+    /// </summary>
+    public class PFF : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.PFF pff = 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);
+
+                // Extract all files
+                pff.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex.Message);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/PKZIP.cs

@@ -0,0 +1,65 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Zip;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// PKWARE ZIP archive and derivatives
+    /// </summary>
+    public class PKZIP : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (ZipArchive zipFile = ZipArchive.Open(stream))
+                {
+                    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);
+                            Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
+                            entry.WriteToFile(tempFile);
+                        }
+                        catch (Exception ex)
+                        {
+                            if (includeDebug) Console.WriteLine(ex);
+                        }
+                    }
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/RAR.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Rar;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// RAR archive
+    /// </summary>
+    public class RAR : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (RarArchive rarFile = RarArchive.Open(stream))
+                {
+                    foreach (var entry in rarFile.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;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/SGA.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// SGA game archive
+    /// </summary>
+    public class SGA : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.SGA sga = 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);
+
+                // Loop through and extract all files
+                sga.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/SevenZip.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Archives;
+using SharpCompress.Archives.SevenZip;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// 7-zip archive
+    /// </summary>
+    public class SevenZip : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (SevenZipArchive sevenZipFile = SevenZipArchive.Open(stream))
+                {
+                    foreach (var entry in sevenZipFile.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;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/TapeArchive.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Tar;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Tape archive
+    /// </summary>
+    public class TapeArchive : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (TarArchive tarFile = TarArchive.Open(stream))
+                {
+                    foreach (var entry in tarFile.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;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/VBSP.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Half-Life 2 Level
+    /// </summary>
+    public class VBSP : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.VBSP vbsp = 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);
+
+                // Loop through and extract all files
+                vbsp.ExtractAllLumps(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex.ToString());
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/VPK.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Valve Package File
+    /// </summary>
+    public class VPK : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.VPK vpk = 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);
+
+                // Loop through and extract all files
+                vpk.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/WAD.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// Half-Life Texture Package File
+    /// </summary>
+    public class WAD : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.WAD wad = 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);
+
+                // Loop through and extract all files
+                wad.ExtractAllLumps(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/XZ.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+using SharpCompress.Compressors.Xz;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// xz archive
+    /// </summary>
+    public class XZ : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create a temp output directory
+                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+                Directory.CreateDirectory(tempPath);
+
+                using (XZStream xzFile = new XZStream(stream))
+                {
+                    string tempFile = Path.Combine(tempPath, Guid.NewGuid().ToString());
+                    using (FileStream fs = File.OpenWrite(tempFile))
+                    {
+                        xzFile.CopyTo(fs);
+                    }
+                }
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}

BinaryObjectScanner.FileType/XZP.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.Interfaces;
+
+namespace BinaryObjectScanner.FileType
+{
+    /// <summary>
+    /// XBox Package File
+    /// </summary>
+    public class XZP : IExtractable
+    {
+        /// <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)
+        {
+            try
+            {
+                // Create the wrapper
+                Wrappers.XZP xzp = 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);
+
+                // Loop through and extract all files
+                xzp.ExtractAll(tempPath);
+
+                return tempPath;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.WriteLine(ex);
+                return null;
+            }
+        }
+    }
+}