mirror of
https://github.com/SabreTools/SabreTools.Serialization.git
synced 2026-04-05 22:01:33 +00:00
776 lines
32 KiB
C#
776 lines
32 KiB
C#
using System;
|
|
using System.IO;
|
|
using SabreTools.IO.Compression.BZip2;
|
|
using SabreTools.IO.Compression.zlib;
|
|
using SabreTools.IO.Extensions;
|
|
using SabreTools.Matching;
|
|
using SabreTools.Numerics.Extensions;
|
|
|
|
namespace SabreTools.Wrappers
|
|
{
|
|
public partial class PortableExecutable : IExtractable
|
|
{
|
|
/// <inheritdoc/>
|
|
/// <remarks>
|
|
/// This extracts the following data:
|
|
/// - Archives and executables in the overlay
|
|
/// - Archives and executables in resource data
|
|
/// - CExe-compressed resource data
|
|
/// - SecuROM Matroschka package sections
|
|
/// - SFX archives
|
|
/// + 7z
|
|
/// + Advanced Installer
|
|
/// + InstallShield Executables
|
|
/// + MS-CAB
|
|
/// + PKZIP
|
|
/// + RAR
|
|
/// + Spoon Installer
|
|
/// - Wise installers
|
|
/// </remarks>
|
|
public bool Extract(string outputDirectory, bool includeDebug)
|
|
{
|
|
bool cai = ExtractAdvancedInstaller(outputDirectory, includeDebug);
|
|
bool cexe = ExtractCExe(outputDirectory, includeDebug);
|
|
bool issexe = ExtractInstallShieldExecutable(outputDirectory, includeDebug);
|
|
bool matroschka = ExtractMatroschka(outputDirectory, includeDebug);
|
|
bool resources = ExtractFromResources(outputDirectory, includeDebug);
|
|
bool spoon = ExtractSpoonInstaller(outputDirectory, includeDebug);
|
|
|
|
// Skip Wise section extraction if the overlay succeeded
|
|
bool wiseOverlay = ExtractWiseOverlay(outputDirectory, includeDebug);
|
|
bool wiseSection = wiseOverlay || ExtractWiseSection(outputDirectory, includeDebug);
|
|
|
|
// Overlay can be skipped in some situations
|
|
bool overlay = cai || issexe || spoon || wiseOverlay
|
|
|| ExtractFromOverlay(outputDirectory, includeDebug);
|
|
|
|
return cai || cexe || issexe || matroschka || overlay || resources
|
|
|| spoon || wiseOverlay || wiseSection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract a Caphyon Advanced Installer SFX overlay
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractAdvancedInstaller(string outputDirectory, bool includeDebug)
|
|
{
|
|
try
|
|
{
|
|
// Ensure the stream is starting at the beginning
|
|
_dataSource.SeekIfPossible(0, SeekOrigin.Begin);
|
|
|
|
// Try to deserialize the source data
|
|
var deserializer = new Serialization.Readers.AdvancedInstaller();
|
|
var sfx = deserializer.Deserialize(_dataSource);
|
|
if (sfx is null || sfx.Entries.Length == 0)
|
|
return false;
|
|
|
|
// Loop through the entries and extract
|
|
for (int i = 0; i < sfx.Entries.Length; i++)
|
|
{
|
|
var entry = sfx.Entries[i];
|
|
|
|
// Get the offset and size
|
|
long offset = entry.FileOffset;
|
|
int size = (int)entry.FileSize;
|
|
|
|
// Try to read the file data
|
|
byte[] data = ReadRangeFromSource(offset, size);
|
|
if (data.Length == 0)
|
|
continue;
|
|
|
|
// Ensure directory separators are consistent
|
|
string filename = entry.Name.Length == 0 ? $"FILE_{i}" : entry.Name;
|
|
if (Path.DirectorySeparatorChar == '\\')
|
|
filename = filename.Replace('/', '\\');
|
|
else if (Path.DirectorySeparatorChar == '/')
|
|
filename = filename.Replace('\\', '/');
|
|
|
|
// Ensure the full output directory exists
|
|
filename = Path.Combine(outputDirectory, filename);
|
|
var directoryName = Path.GetDirectoryName(filename);
|
|
if (directoryName is not null && !Directory.Exists(directoryName))
|
|
Directory.CreateDirectory(directoryName);
|
|
|
|
// Write the output file
|
|
var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
|
|
fs.Write(data, 0, data.Length);
|
|
fs.Flush();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract a CExe-compressed executable
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractCExe(string outputDirectory, bool includeDebug)
|
|
{
|
|
try
|
|
{
|
|
// Get all resources of type 99 with index 2
|
|
var resources = FindResourceByNamedType("99, 2");
|
|
if (resources is null || resources.Count == 0)
|
|
return false;
|
|
|
|
// Get the first resource of type 99 with index 2
|
|
var resource = resources[0];
|
|
if (resource is null || resource.Length == 0)
|
|
return false;
|
|
|
|
// Create the output data buffer
|
|
byte[]? data = [];
|
|
|
|
// If we had the decompression DLL included, it's zlib
|
|
if (FindResourceByNamedType("99, 1").Count > 0)
|
|
data = DecompressCExeZlib(resource);
|
|
else
|
|
data = DecompressCExeLZ(resource);
|
|
|
|
// If we have no data
|
|
if (data is null)
|
|
return false;
|
|
|
|
// Create the temp filename
|
|
string tempFile = string.IsNullOrEmpty(Filename) ? "temp.sxe" : $"{Path.GetFileNameWithoutExtension(Filename)}.sxe";
|
|
tempFile = Path.Combine(outputDirectory, tempFile);
|
|
var directoryName = Path.GetDirectoryName(tempFile);
|
|
if (directoryName is not null && !Directory.Exists(directoryName))
|
|
Directory.CreateDirectory(directoryName);
|
|
|
|
// Write the file data to a temp file
|
|
var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
|
|
tempStream.Write(data, 0, data.Length);
|
|
tempStream.Flush();
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract data from the overlay
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractFromOverlay(string outputDirectory, bool includeDebug)
|
|
{
|
|
try
|
|
{
|
|
// Cache the overlay data for easier reading
|
|
var overlayData = OverlayData;
|
|
if (overlayData.Length == 0)
|
|
return false;
|
|
|
|
// Set the output variables
|
|
int overlayOffset = 0;
|
|
string extension = string.Empty;
|
|
|
|
// Only process the overlay if it is recognized
|
|
for (; overlayOffset < 0x400 && overlayOffset < overlayData.Length - 0x10; overlayOffset++)
|
|
{
|
|
int temp = overlayOffset;
|
|
byte[] overlaySample = overlayData.ReadBytes(ref temp, 0x10);
|
|
|
|
if (overlaySample.StartsWith(Data.Models.SevenZip.Constants.SignatureBytes))
|
|
{
|
|
extension = "7z";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0x3B, 0x21, 0x40, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6C, 0x6C]))
|
|
{
|
|
// 7-zip SFX script -- ";!@Install" to ";!@InstallEnd@!"
|
|
overlayOffset = overlayData.FirstPosition([0x3B, 0x21, 0x40, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6C, 0x6C, 0x45, 0x6E, 0x64, 0x40, 0x21]);
|
|
if (overlayOffset == -1)
|
|
return false;
|
|
|
|
overlayOffset += 15;
|
|
extension = "7z";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.BZip2.Constants.SignatureBytes))
|
|
{
|
|
extension = "bz2";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.CFB.Constants.SignatureBytes))
|
|
{
|
|
// Assume embedded CFB files are MSI
|
|
extension = "msi";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0x1F, 0x8B]))
|
|
{
|
|
extension = "gz";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.MicrosoftCabinet.Constants.SignatureBytes))
|
|
{
|
|
extension = "cab";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.PKZIP.Constants.LocalFileHeaderSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.PKZIP.Constants.EndOfCentralDirectoryRecordSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.PKZIP.Constants.EndOfCentralDirectoryRecord64SignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.PKZIP.Constants.DataDescriptorSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.RAR.Constants.OldSignatureBytes))
|
|
{
|
|
extension = "rar";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.RAR.Constants.NewSignatureBytes))
|
|
{
|
|
extension = "rar";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0x55, 0x48, 0x41, 0x06]))
|
|
{
|
|
extension = "uha";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0x3C, 0x3F, 0x78, 0x6D, 0x6C]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00, 0x6D, 0x00, 0x6C, 0x00]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith([0xFF, 0xFE, 0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00, 0x6D, 0x00, 0x6C, 0x00]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.XZ.Constants.HeaderSignatureBytes))
|
|
{
|
|
extension = "xz";
|
|
break;
|
|
}
|
|
else if (overlaySample.StartsWith(Data.Models.MSDOS.Constants.SignatureBytes))
|
|
{
|
|
extension = "bin"; // exe/dll
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If the extension is unset
|
|
if (extension.Length == 0)
|
|
return false;
|
|
|
|
// Create the temp filename
|
|
string tempFile = $"embedded_overlay.{extension}";
|
|
if (Filename is not null)
|
|
tempFile = $"{Path.GetFileName(Filename)}-{tempFile}";
|
|
|
|
tempFile = Path.Combine(outputDirectory, tempFile);
|
|
var directoryName = Path.GetDirectoryName(tempFile);
|
|
if (directoryName is not 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 the overlay is partially cached, read it from the source in blocks
|
|
if (OverlaySize > overlayData.Length)
|
|
{
|
|
long currentOffset = OverlayAddress + overlayOffset;
|
|
long bytesLeft = OverlaySize - overlayOffset;
|
|
|
|
while (bytesLeft > 0)
|
|
{
|
|
int bytesToRead = (int)Math.Min(0x4000, bytesLeft);
|
|
byte[] buffer = ReadRangeFromSource(currentOffset, bytesToRead);
|
|
if (buffer.Length == 0)
|
|
break;
|
|
|
|
tempStream.Write(buffer, 0, buffer.Length);
|
|
tempStream.Flush();
|
|
|
|
currentOffset += bytesToRead;
|
|
bytesLeft -= bytesToRead;
|
|
}
|
|
}
|
|
|
|
// Otherwise, read from the cached data
|
|
else
|
|
{
|
|
tempStream.Write(overlayData, overlayOffset, overlayData.Length - overlayOffset);
|
|
tempStream.Flush();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract data from the resources
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractFromResources(string outputDirectory, bool includeDebug)
|
|
{
|
|
try
|
|
{
|
|
// Cache the resource data for easier reading
|
|
var resourceData = ResourceData;
|
|
if (resourceData.Count == 0)
|
|
return false;
|
|
|
|
// Get the resources that have an archive signature
|
|
int i = 0;
|
|
foreach (var kvp in resourceData)
|
|
{
|
|
// Get the key and value
|
|
string resourceKey = kvp.Key;
|
|
var value = kvp.Value;
|
|
|
|
if (value is null || value is not Data.Models.PortableExecutable.Resource.Entries.GenericResourceEntry ba || ba.Data.Length == 0)
|
|
continue;
|
|
|
|
// Set the output variables
|
|
int resourceOffset = 0;
|
|
string extension = string.Empty;
|
|
|
|
// Only process the resource if it a recognized signature
|
|
for (; resourceOffset < 0x400 && resourceOffset < ba.Data.Length - 0x10; resourceOffset++)
|
|
{
|
|
int temp = resourceOffset;
|
|
byte[] resourceSample = ba.Data.ReadBytes(ref temp, 0x10);
|
|
|
|
if (resourceSample.StartsWith(Data.Models.SevenZip.Constants.SignatureBytes))
|
|
{
|
|
extension = "7z";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x42, 0x4D]))
|
|
{
|
|
extension = "bmp";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.BZip2.Constants.SignatureBytes))
|
|
{
|
|
extension = "bz2";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.CFB.Constants.SignatureBytes))
|
|
{
|
|
// Assume embedded CFB files are MSI
|
|
extension = "msi";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x47, 0x49, 0x46, 0x38]))
|
|
{
|
|
extension = "gif";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x1F, 0x8B]))
|
|
{
|
|
extension = "gz";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0xFF, 0xD8, 0xFF, 0xE0]))
|
|
{
|
|
extension = "jpg";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x3C, 0x68, 0x74, 0x6D, 0x6C]))
|
|
{
|
|
extension = "html";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.MicrosoftCabinet.Constants.SignatureBytes))
|
|
{
|
|
extension = "cab";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.PKZIP.Constants.LocalFileHeaderSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.PKZIP.Constants.EndOfCentralDirectoryRecordSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.PKZIP.Constants.EndOfCentralDirectoryRecord64SignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.PKZIP.Constants.DataDescriptorSignatureBytes))
|
|
{
|
|
extension = "zip";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x89, 0x50, 0x4E, 0x47]))
|
|
{
|
|
extension = "png";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.RAR.Constants.OldSignatureBytes))
|
|
{
|
|
extension = "rar";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.RAR.Constants.NewSignatureBytes))
|
|
{
|
|
extension = "rar";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x55, 0x48, 0x41, 0x06]))
|
|
{
|
|
extension = "uha";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x3C, 0x3F, 0x78, 0x6D, 0x6C]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00, 0x6D, 0x00, 0x6C, 0x00]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith([0xFF, 0xFE, 0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00, 0x6D, 0x00, 0x6C, 0x00]))
|
|
{
|
|
extension = "xml";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.XZ.Constants.HeaderSignatureBytes))
|
|
{
|
|
extension = "xz";
|
|
break;
|
|
}
|
|
else if (resourceSample.StartsWith(Data.Models.MSDOS.Constants.SignatureBytes))
|
|
{
|
|
extension = "bin"; // exe/dll
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If the extension is unset
|
|
if (extension.Length == 0)
|
|
continue;
|
|
|
|
try
|
|
{
|
|
// Create the temp filename
|
|
string tempFile = $"embedded_resource_{i++} ({resourceKey}).{extension}";
|
|
if (Filename is not null)
|
|
tempFile = $"{Path.GetFileName(Filename)}-{tempFile}";
|
|
|
|
tempFile = Path.Combine(outputDirectory, tempFile);
|
|
var directoryName = Path.GetDirectoryName(tempFile);
|
|
if (directoryName is not 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);
|
|
tempStream.Write(ba.Data, resourceOffset, ba.Data.Length - resourceOffset);
|
|
tempStream.Flush();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract data from a SecuROM Matroschka Package
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractMatroschka(string outputDirectory, bool includeDebug)
|
|
{
|
|
// Check if executable contains Matroschka package or not
|
|
if (MatroschkaPackage is null)
|
|
return false;
|
|
|
|
// Attempt to extract package
|
|
return MatroschkaPackage.Extract(outputDirectory, includeDebug);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract data from an Installshield Executable
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractInstallShieldExecutable(string outputDirectory, bool includeDebug)
|
|
{
|
|
// Check if executable contains an InstallShield Executable or not
|
|
if (ISEXE is null)
|
|
return false;
|
|
|
|
// Attempt to extract package
|
|
return ISEXE.Extract(outputDirectory, includeDebug);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract a Spoon Installer SFX overlay
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractSpoonInstaller(string outputDirectory, bool includeDebug)
|
|
{
|
|
try
|
|
{
|
|
// Ensure the stream is starting at the beginning
|
|
_dataSource.SeekIfPossible(0, SeekOrigin.Begin);
|
|
|
|
// Try to deserialize the source data
|
|
var deserializer = new Serialization.Readers.SpoonInstaller();
|
|
var sfx = deserializer.Deserialize(_dataSource);
|
|
if (sfx?.Entries is null)
|
|
return false;
|
|
|
|
// Loop through the entries and extract
|
|
for (int i = 0; i < sfx.Entries.Length; i++)
|
|
{
|
|
var entry = sfx.Entries[i];
|
|
|
|
// Get the offset and compressed size
|
|
long offset = entry.FileOffset;
|
|
int compressed = (int)entry.CompressedSize;
|
|
int extracted = (int)entry.UncompressedSize;
|
|
|
|
// Try to read the file data
|
|
byte[] bz2Data = ReadRangeFromSource(offset, compressed);
|
|
if (bz2Data.Length == 0)
|
|
continue;
|
|
|
|
// Try opening the stream
|
|
using var ms = new MemoryStream(bz2Data);
|
|
using var bz2File = new BZip2InputStream(ms, false);
|
|
|
|
// Try to read the decompressed data
|
|
byte[] data = bz2File.ReadBytes(extracted);
|
|
|
|
// Ensure directory separators are consistent
|
|
string filename = entry.Filename?.TrimEnd('\0') ?? $"FILE_{i}";
|
|
if (Path.DirectorySeparatorChar == '\\')
|
|
filename = filename.Replace('/', '\\');
|
|
else if (Path.DirectorySeparatorChar == '/')
|
|
filename = filename.Replace('\\', '/');
|
|
|
|
// Ensure the full output directory exists
|
|
filename = Path.Combine(outputDirectory, filename);
|
|
var directoryName = Path.GetDirectoryName(filename);
|
|
if (directoryName is not null && !Directory.Exists(directoryName))
|
|
Directory.CreateDirectory(directoryName);
|
|
|
|
// Write the output file
|
|
var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
|
|
fs.Write(data, 0, data.Length);
|
|
fs.Flush();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract data from a Wise installer
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractWiseOverlay(string outputDirectory, bool includeDebug)
|
|
{
|
|
// Get the source data for reading
|
|
Stream source = _dataSource;
|
|
if (Filename is not null)
|
|
{
|
|
// Try to open a multipart file
|
|
if (WiseOverlayHeader.OpenFile(Filename, includeDebug, out var temp) && temp is not null)
|
|
source = temp;
|
|
}
|
|
|
|
// Try to find the overlay header
|
|
long offset = FindWiseOverlayHeader();
|
|
if (offset <= 0 || offset > Length)
|
|
return false;
|
|
|
|
// Seek to the overlay and parse
|
|
source.SeekIfPossible(offset, SeekOrigin.Begin);
|
|
var header = WiseOverlayHeader.Create(source);
|
|
if (header is null)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine("Could not parse a Wise overlay header");
|
|
return false;
|
|
}
|
|
|
|
// Extract the header-defined files
|
|
bool extracted = header.ExtractHeaderDefinedFiles(outputDirectory, includeDebug);
|
|
if (!extracted)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine("Could not extract Wise overlay header-defined files");
|
|
return false;
|
|
}
|
|
|
|
// Open the script file from the output directory
|
|
var scriptStream = File.OpenRead(Path.Combine(outputDirectory, "WiseScript.bin"));
|
|
var script = WiseScript.Create(scriptStream);
|
|
if (script is null)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine("Could not parse WiseScript.bin");
|
|
return false;
|
|
}
|
|
|
|
// Get the source directory
|
|
string? sourceDirectory = null;
|
|
if (Filename is not null)
|
|
sourceDirectory = Path.GetDirectoryName(Path.GetFullPath(Filename));
|
|
|
|
// Process the state machine
|
|
return script.ProcessStateMachine(header, sourceDirectory, outputDirectory, includeDebug);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract using Wise section
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <param name="includeDebug">True to include debug data, false otherwise</param>
|
|
/// <returns>True if extraction succeeded, false otherwise</returns>
|
|
public bool ExtractWiseSection(string outputDirectory, bool includeDebug)
|
|
{
|
|
// Get the section header
|
|
var header = WiseSection;
|
|
if (header is null)
|
|
{
|
|
if (includeDebug) Console.Error.WriteLine("Could not parse a Wise section header");
|
|
return false;
|
|
}
|
|
|
|
// Attempt to extract section
|
|
return header.Extract(outputDirectory, includeDebug);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decompress CExe data compressed with LZ
|
|
/// </summary>
|
|
/// <param name="resource">Resource data to inflate</param>
|
|
/// <returns>Inflated data on success, null otherwise</returns>
|
|
private static byte[]? DecompressCExeLZ(byte[] resource)
|
|
{
|
|
try
|
|
{
|
|
var decompressor = IO.Compression.SZDD.Decompressor.CreateSZDD(resource);
|
|
using var dataStream = new MemoryStream();
|
|
decompressor.CopyTo(dataStream);
|
|
return dataStream.ToArray();
|
|
}
|
|
catch
|
|
{
|
|
// Reset the data
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decompress CExe data compressed with zlib
|
|
/// </summary>
|
|
/// <param name="resource">Resource data to inflate</param>
|
|
/// <returns>Inflated data on success, null otherwise</returns>
|
|
private static byte[]? DecompressCExeZlib(byte[] resource)
|
|
{
|
|
try
|
|
{
|
|
// Inflate the data into the buffer
|
|
var zstream = new ZLib.z_stream_s();
|
|
byte[] data = new byte[resource.Length * 4];
|
|
unsafe
|
|
{
|
|
fixed (byte* payloadPtr = resource, dataPtr = data)
|
|
{
|
|
zstream.next_in = payloadPtr;
|
|
zstream.avail_in = (uint)resource.Length;
|
|
zstream.total_in = (uint)resource.Length;
|
|
zstream.next_out = dataPtr;
|
|
zstream.avail_out = (uint)data.Length;
|
|
zstream.total_out = 0;
|
|
|
|
ZLib.inflateInit_(zstream, ZLib.zlibVersion(), resource.Length);
|
|
int zret = ZLib.inflate(zstream, 1);
|
|
ZLib.inflateEnd(zstream);
|
|
}
|
|
}
|
|
|
|
// Trim the buffer to the proper size
|
|
uint read = zstream.total_out;
|
|
#if NETFRAMEWORK
|
|
var temp = new byte[read];
|
|
Array.Copy(data, temp, read);
|
|
data = temp;
|
|
#else
|
|
data = new ReadOnlySpan<byte>(data, 0, (int)read).ToArray();
|
|
#endif
|
|
return data;
|
|
}
|
|
catch
|
|
{
|
|
// Reset the data
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|