SabreTools/BinaryObjectScanner
1
0
Fork 0
mirror of https://github.com/SabreTools/BinaryObjectScanner.git synced 2026-09-24 07:44:55 +00:00
Code Issues 295 Packages Projects Releases 20 Wiki Activity

Migrate to Nuget package for Models

Browse Source
This commit is contained in:
Matt Nadareski
2023-09-04 23:44:45 -04:00
parent fb6fa85cd3
commit a9454e96ed
442 changed files with 764 additions and 24721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
BinaryObjectScanner.Builders/AACS.cs
View File

@@ -2,8 +2,8 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.AACS;
using BinaryObjectScanner.Utilities;
using SabreTools.Models.AACS;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/BDPlus.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.BDPlus;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.BDPlus.Constants;
using SabreTools.Models.BDPlus;
using static SabreTools.Models.BDPlus.Constants;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/BFPK.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.BFPK;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.BFPK.Constants;
using SabreTools.Models.BFPK;
using static SabreTools.Models.BFPK.Constants;
namespace BinaryObjectScanner.Builders
{

10
BinaryObjectScanner.Builders/BSP.cs
View File

@@ -1,9 +1,9 @@
using System.IO;
using System.Linq;
using System.Text;
using BinaryObjectScanner.Models.BSP;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.BSP.Constants;
using SabreTools.Models.BSP;
using static SabreTools.Models.BSP.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -17,7 +17,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life Level on success, null on error</returns>
public static Models.BSP.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.BSP.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -41,7 +41,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life Level on success, null on error</returns>
public static Models.BSP.File ParseFile(Stream data)
public static SabreTools.Models.BSP.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -55,7 +55,7 @@ namespace BinaryObjectScanner.Builders
int initialOffset = (int)data.Position;
// Create a new Half-Life Level to fill
var file = new Models.BSP.File();
var file = new SabreTools.Models.BSP.File();
#region Header

5
BinaryObjectScanner.Builders/BinaryObjectScanner.Builders.csproj
View File

@@ -21,8 +21,11 @@
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\BinaryObjectScanner.Models\BinaryObjectScanner.Models.csproj" />
<ProjectReference Include="..\BinaryObjectScanner.Utilities\BinaryObjectScanner.Utilities.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="SabreTools.Models" Version="1.1.0" />
</ItemGroup>
</Project>

4
BinaryObjectScanner.Builders/CFB.cs
View File

@@ -2,9 +2,9 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.CFB;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.CFB.Constants;
using SabreTools.Models.CFB;
using static SabreTools.Models.CFB.Constants;
namespace BinaryObjectScanner.Builders
{

202
BinaryObjectScanner.Builders/Extensions.cs
View File

@@ -17,7 +17,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource type information entry to check</param>
/// <returns>True if the entry is an integer type, false if an offset, null on error</returns>
public static bool? IsIntegerType(this Models.NewExecutable.ResourceTypeInformationEntry entry)
public static bool? IsIntegerType(this SabreTools.Models.NewExecutable.ResourceTypeInformationEntry entry)
{
// We can't do anything with an invalid entry
if (entry == null)
@@ -32,7 +32,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource type resource entry to check</param>
/// <returns>True if the entry is an integer type, false if an offset, null on error</returns>
public static bool? IsIntegerType(this Models.NewExecutable.ResourceTypeResourceEntry entry)
public static bool? IsIntegerType(this SabreTools.Models.NewExecutable.ResourceTypeResourceEntry entry)
{
// We can't do anything with an invalid entry
if (entry == null)
@@ -47,22 +47,22 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Entry table bundle to check</param>
/// <returns>SegmentEntryType corresponding to the type</returns>
public static Models.NewExecutable.SegmentEntryType GetEntryType(this Models.NewExecutable.EntryTableBundle entry)
public static SabreTools.Models.NewExecutable.SegmentEntryType GetEntryType(this SabreTools.Models.NewExecutable.EntryTableBundle entry)
{
// We can't do anything with an invalid entry
if (entry == null)
return Models.NewExecutable.SegmentEntryType.Unused;
return SabreTools.Models.NewExecutable.SegmentEntryType.Unused;
// Determine the entry type based on segment indicator
if (entry.SegmentIndicator == 0x00)
return Models.NewExecutable.SegmentEntryType.Unused;
return SabreTools.Models.NewExecutable.SegmentEntryType.Unused;
else if (entry.SegmentIndicator >= 0x01 && entry.SegmentIndicator <= 0xFE)
return Models.NewExecutable.SegmentEntryType.FixedSegment;
return SabreTools.Models.NewExecutable.SegmentEntryType.FixedSegment;
else if (entry.SegmentIndicator == 0xFF)
return Models.NewExecutable.SegmentEntryType.MoveableSegment;
return SabreTools.Models.NewExecutable.SegmentEntryType.MoveableSegment;
// We should never get here
return Models.NewExecutable.SegmentEntryType.Unused;
return SabreTools.Models.NewExecutable.SegmentEntryType.Unused;
}
#endregion
@@ -75,7 +75,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="rva">Relative virtual address to convert</param>
/// <param name="sections">Array of sections to check against</param>
/// <returns>Physical address, 0 on error</returns>
public static uint ConvertVirtualAddress(this uint rva, Models.PortableExecutable.SectionHeader[] sections)
public static uint ConvertVirtualAddress(this uint rva, SabreTools.Models.PortableExecutable.SectionHeader[] sections)
{
// If we have an invalid section table, we can't do anything
if (sections == null || sections.Length == 0)
@@ -118,7 +118,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="rva">Relative virtual address to convert</param>
/// <param name="sections">Array of sections to check against</param>
/// <returns>Section index, null on error</returns>
public static int ContainingSectionIndex(this uint rva, Models.PortableExecutable.SectionHeader[] sections)
public static int ContainingSectionIndex(this uint rva, SabreTools.Models.PortableExecutable.SectionHeader[] sections)
{
// If we have an invalid section table, we can't do anything
if (sections == null || sections.Length == 0)
@@ -156,14 +156,14 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into overlay data</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled SecuROM AddD overlay data on success, null on error</returns>
public static Models.PortableExecutable.SecuROMAddD AsSecuROMAddD(this byte[] data, ref int offset)
public static SabreTools.Models.PortableExecutable.SecuROMAddD AsSecuROMAddD(this byte[] data, ref int offset)
{
// If we have data that's invalid, we can't do anything
if (data == null)
return null;
// Read in the table
var addD = new Models.PortableExecutable.SecuROMAddD();
var addD = new SabreTools.Models.PortableExecutable.SecuROMAddD();
addD.Signature = data.ReadUInt32(ref offset);
if (addD.Signature != 0x44646441)
@@ -189,10 +189,10 @@ namespace BinaryObjectScanner.Builders
addD.Unknown14h = data.ReadBytes(ref offset, bytesToRead);
addD.Entries = new Models.PortableExecutable.SecuROMAddDEntry[addD.EntryCount];
addD.Entries = new SabreTools.Models.PortableExecutable.SecuROMAddDEntry[addD.EntryCount];
for (int i = 0; i < addD.EntryCount; i++)
{
var addDEntry = new Models.PortableExecutable.SecuROMAddDEntry();
var addDEntry = new SabreTools.Models.PortableExecutable.SecuROMAddDEntry();
addDEntry.PhysicalOffset = data.ReadUInt32(ref offset);
addDEntry.Length = data.ReadUInt32(ref offset);
@@ -219,13 +219,13 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into a database</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled NB10 Program Database on success, null on error</returns>
public static Models.PortableExecutable.NB10ProgramDatabase AsNB10ProgramDatabase(this byte[] data, ref int offset)
public static SabreTools.Models.PortableExecutable.NB10ProgramDatabase AsNB10ProgramDatabase(this byte[] data, ref int offset)
{
// If we have data that's invalid, we can't do anything
if (data == null)
return null;
var nb10ProgramDatabase = new Models.PortableExecutable.NB10ProgramDatabase();
var nb10ProgramDatabase = new SabreTools.Models.PortableExecutable.NB10ProgramDatabase();
nb10ProgramDatabase.Signature = data.ReadUInt32(ref offset);
if (nb10ProgramDatabase.Signature != 0x3031424E)
@@ -245,13 +245,13 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into a database</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled RSDS Program Database on success, null on error</returns>
public static Models.PortableExecutable.RSDSProgramDatabase AsRSDSProgramDatabase(this byte[] data, ref int offset)
public static SabreTools.Models.PortableExecutable.RSDSProgramDatabase AsRSDSProgramDatabase(this byte[] data, ref int offset)
{
// If we have data that's invalid, we can't do anything
if (data == null)
return null;
var rsdsProgramDatabase = new Models.PortableExecutable.RSDSProgramDatabase();
var rsdsProgramDatabase = new SabreTools.Models.PortableExecutable.RSDSProgramDatabase();
rsdsProgramDatabase.Signature = data.ReadUInt32(ref offset);
if (rsdsProgramDatabase.Signature != 0x53445352)
@@ -275,20 +275,20 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into a resource header</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled resource header on success, null on error</returns>
public static Models.PortableExecutable.ResourceHeader AsResourceHeader(this byte[] data, ref int offset)
public static SabreTools.Models.PortableExecutable.ResourceHeader AsResourceHeader(this byte[] data, ref int offset)
{
// If we have data that's invalid, we can't do anything
if (data == null)
return null;
// Read in the table
var header = new Models.PortableExecutable.ResourceHeader();
var header = new SabreTools.Models.PortableExecutable.ResourceHeader();
header.DataSize = data.ReadUInt32(ref offset);
header.HeaderSize = data.ReadUInt32(ref offset);
header.ResourceType = (Models.PortableExecutable.ResourceType)data.ReadUInt32(ref offset); // TODO: Could be a string too
header.ResourceType = (SabreTools.Models.PortableExecutable.ResourceType)data.ReadUInt32(ref offset); // TODO: Could be a string too
header.Name = data.ReadUInt32(ref offset); // TODO: Could be a string too
header.DataVersion = data.ReadUInt32(ref offset);
header.MemoryFlags = (Models.PortableExecutable.MemoryFlags)data.ReadUInt16(ref offset);
header.MemoryFlags = (SabreTools.Models.PortableExecutable.MemoryFlags)data.ReadUInt16(ref offset);
header.LanguageId = data.ReadUInt16(ref offset);
header.Version = data.ReadUInt32(ref offset);
header.Characteristics = data.ReadUInt32(ref offset);
@@ -301,7 +301,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into an accelerator table resource</param>
/// <returns>A filled accelerator table resource on success, null on error</returns>
public static Models.PortableExecutable.AcceleratorTableEntry[] AsAcceleratorTableResource(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.AcceleratorTableEntry[] AsAcceleratorTableResource(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have data that's invalid for this resource type, we can't do anything
if (entry?.Data == null || entry.Data.Length % 8 != 0)
@@ -314,14 +314,14 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var table = new Models.PortableExecutable.AcceleratorTableEntry[count];
var table = new SabreTools.Models.PortableExecutable.AcceleratorTableEntry[count];
// Read in the table
for (int i = 0; i < count; i++)
{
var acceleratorTableEntry = new Models.PortableExecutable.AcceleratorTableEntry();
var acceleratorTableEntry = new SabreTools.Models.PortableExecutable.AcceleratorTableEntry();
acceleratorTableEntry.Flags = (Models.PortableExecutable.AcceleratorTableFlags)entry.Data.ReadUInt16(ref offset);
acceleratorTableEntry.Flags = (SabreTools.Models.PortableExecutable.AcceleratorTableFlags)entry.Data.ReadUInt16(ref offset);
acceleratorTableEntry.Ansi = entry.Data.ReadUInt16(ref offset);
acceleratorTableEntry.Id = entry.Data.ReadUInt16(ref offset);
acceleratorTableEntry.Padding = entry.Data.ReadUInt16(ref offset);
@@ -337,7 +337,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a side-by-side assembly manifest</param>
/// <returns>A filled side-by-side assembly manifest on success, null on error</returns>
public static Models.PortableExecutable.AssemblyManifest AsAssemblyManifest(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.AssemblyManifest AsAssemblyManifest(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -345,8 +345,8 @@ namespace BinaryObjectScanner.Builders
try
{
XmlSerializer serializer = new XmlSerializer(typeof(Models.PortableExecutable.AssemblyManifest));
return serializer.Deserialize(new MemoryStream(entry.Data)) as Models.PortableExecutable.AssemblyManifest;
XmlSerializer serializer = new XmlSerializer(typeof(SabreTools.Models.PortableExecutable.AssemblyManifest));
return serializer.Deserialize(new MemoryStream(entry.Data)) as SabreTools.Models.PortableExecutable.AssemblyManifest;
}
catch
{
@@ -359,7 +359,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a dialog box</param>
/// <returns>A filled dialog box on success, null on error</returns>
public static Models.PortableExecutable.DialogBoxResource AsDialogBox(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.DialogBoxResource AsDialogBox(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -369,7 +369,7 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var dialogBoxResource = new Models.PortableExecutable.DialogBoxResource();
var dialogBoxResource = new SabreTools.Models.PortableExecutable.DialogBoxResource();
// Try to read the signature for an extended dialog box template
int signatureOffset = sizeof(ushort);
@@ -378,13 +378,13 @@ namespace BinaryObjectScanner.Builders
{
#region Extended dialog template
var dialogTemplateExtended = new Models.PortableExecutable.DialogTemplateExtended();
var dialogTemplateExtended = new SabreTools.Models.PortableExecutable.DialogTemplateExtended();
dialogTemplateExtended.Version = entry.Data.ReadUInt16(ref offset);
dialogTemplateExtended.Signature = entry.Data.ReadUInt16(ref offset);
dialogTemplateExtended.HelpID = entry.Data.ReadUInt32(ref offset);
dialogTemplateExtended.ExtendedStyle = (Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplateExtended.Style = (Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplateExtended.ExtendedStyle = (SabreTools.Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplateExtended.Style = (SabreTools.Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplateExtended.DialogItems = entry.Data.ReadUInt16(ref offset);
dialogTemplateExtended.PositionX = entry.Data.ReadInt16(ref offset);
dialogTemplateExtended.PositionY = entry.Data.ReadInt16(ref offset);
@@ -493,7 +493,7 @@ namespace BinaryObjectScanner.Builders
#region Point size and typeface
// Only if DS_SETFONT is set are the values here used
if (dialogTemplateExtended.Style.HasFlag(Models.PortableExecutable.WindowStyles.DS_SETFONT))
if (dialogTemplateExtended.Style.HasFlag(SabreTools.Models.PortableExecutable.WindowStyles.DS_SETFONT))
{
dialogTemplateExtended.PointSize = entry.Data.ReadUInt16(ref offset);
dialogTemplateExtended.Weight = entry.Data.ReadUInt16(ref offset);
@@ -517,15 +517,15 @@ namespace BinaryObjectScanner.Builders
#region Extended dialog item templates
var dialogItemExtendedTemplates = new List<Models.PortableExecutable.DialogItemTemplateExtended>();
var dialogItemExtendedTemplates = new List<SabreTools.Models.PortableExecutable.DialogItemTemplateExtended>();
for (int i = 0; i < dialogTemplateExtended.DialogItems; i++)
{
var dialogItemTemplate = new Models.PortableExecutable.DialogItemTemplateExtended();
var dialogItemTemplate = new SabreTools.Models.PortableExecutable.DialogItemTemplateExtended();
dialogItemTemplate.HelpID = entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.ExtendedStyle = (Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.Style = (Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.ExtendedStyle = (SabreTools.Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.Style = (SabreTools.Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.PositionX = entry.Data.ReadInt16(ref offset);
dialogItemTemplate.PositionY = entry.Data.ReadInt16(ref offset);
dialogItemTemplate.WidthX = entry.Data.ReadInt16(ref offset);
@@ -545,7 +545,7 @@ namespace BinaryObjectScanner.Builders
_ = entry.Data.ReadUInt16(ref offset);
// Read the ordinal
dialogItemTemplate.ClassResourceOrdinal = (Models.PortableExecutable.DialogItemTemplateOrdinal)entry.Data.ReadUInt16(ref offset);
dialogItemTemplate.ClassResourceOrdinal = (SabreTools.Models.PortableExecutable.DialogItemTemplateOrdinal)entry.Data.ReadUInt16(ref offset);
}
else
{
@@ -623,10 +623,10 @@ namespace BinaryObjectScanner.Builders
{
#region Dialog template
var dialogTemplate = new Models.PortableExecutable.DialogTemplate();
var dialogTemplate = new SabreTools.Models.PortableExecutable.DialogTemplate();
dialogTemplate.Style = (Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplate.ExtendedStyle = (Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplate.Style = (SabreTools.Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplate.ExtendedStyle = (SabreTools.Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogTemplate.ItemCount = entry.Data.ReadUInt16(ref offset);
dialogTemplate.PositionX = entry.Data.ReadInt16(ref offset);
dialogTemplate.PositionY = entry.Data.ReadInt16(ref offset);
@@ -735,7 +735,7 @@ namespace BinaryObjectScanner.Builders
#region Point size and typeface
// Only if DS_SETFONT is set are the values here used
if (dialogTemplate.Style.HasFlag(Models.PortableExecutable.WindowStyles.DS_SETFONT))
if (dialogTemplate.Style.HasFlag(SabreTools.Models.PortableExecutable.WindowStyles.DS_SETFONT))
{
dialogTemplate.PointSizeValue = entry.Data.ReadUInt16(ref offset);
@@ -758,14 +758,14 @@ namespace BinaryObjectScanner.Builders
#region Dialog item templates
var dialogItemTemplates = new List<Models.PortableExecutable.DialogItemTemplate>();
var dialogItemTemplates = new List<SabreTools.Models.PortableExecutable.DialogItemTemplate>();
for (int i = 0; i < dialogTemplate.ItemCount; i++)
{
var dialogItemTemplate = new Models.PortableExecutable.DialogItemTemplate();
var dialogItemTemplate = new SabreTools.Models.PortableExecutable.DialogItemTemplate();
dialogItemTemplate.Style = (Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.ExtendedStyle = (Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.Style = (SabreTools.Models.PortableExecutable.WindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.ExtendedStyle = (SabreTools.Models.PortableExecutable.ExtendedWindowStyles)entry.Data.ReadUInt32(ref offset);
dialogItemTemplate.PositionX = entry.Data.ReadInt16(ref offset);
dialogItemTemplate.PositionY = entry.Data.ReadInt16(ref offset);
dialogItemTemplate.WidthX = entry.Data.ReadInt16(ref offset);
@@ -785,7 +785,7 @@ namespace BinaryObjectScanner.Builders
_ = entry.Data.ReadUInt16(ref offset);
// Read the ordinal
dialogItemTemplate.ClassResourceOrdinal = (Models.PortableExecutable.DialogItemTemplateOrdinal)entry.Data.ReadUInt16(ref offset);
dialogItemTemplate.ClassResourceOrdinal = (SabreTools.Models.PortableExecutable.DialogItemTemplateOrdinal)entry.Data.ReadUInt16(ref offset);
}
else
{
@@ -868,7 +868,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a font group</param>
/// <returns>A filled font group on success, null on error</returns>
public static Models.PortableExecutable.FontGroupHeader AsFontGroup(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.FontGroupHeader AsFontGroup(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -878,19 +878,19 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var fontGroupHeader = new Models.PortableExecutable.FontGroupHeader();
var fontGroupHeader = new SabreTools.Models.PortableExecutable.FontGroupHeader();
fontGroupHeader.NumberOfFonts = entry.Data.ReadUInt16(ref offset);
if (fontGroupHeader.NumberOfFonts > 0)
{
fontGroupHeader.DE = new Models.PortableExecutable.DirEntry[fontGroupHeader.NumberOfFonts];
fontGroupHeader.DE = new SabreTools.Models.PortableExecutable.DirEntry[fontGroupHeader.NumberOfFonts];
for (int i = 0; i < fontGroupHeader.NumberOfFonts; i++)
{
var dirEntry = new Models.PortableExecutable.DirEntry();
var dirEntry = new SabreTools.Models.PortableExecutable.DirEntry();
dirEntry.FontOrdinal = entry.Data.ReadUInt16(ref offset);
dirEntry.Entry = new Models.PortableExecutable.FontDirEntry();
dirEntry.Entry = new SabreTools.Models.PortableExecutable.FontDirEntry();
dirEntry.Entry.Version = entry.Data.ReadUInt16(ref offset);
dirEntry.Entry.Size = entry.Data.ReadUInt32(ref offset);
dirEntry.Entry.Copyright = entry.Data.ReadBytes(ref offset, 60);
@@ -937,7 +937,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a menu</param>
/// <returns>A filled menu on success, null on error</returns>
public static Models.PortableExecutable.MenuResource AsMenu(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.MenuResource AsMenu(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -947,7 +947,7 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var menuResource = new Models.PortableExecutable.MenuResource();
var menuResource = new SabreTools.Models.PortableExecutable.MenuResource();
// Try to read the version for an extended header
int versionOffset = 0;
@@ -956,7 +956,7 @@ namespace BinaryObjectScanner.Builders
{
#region Extended menu header
var menuHeaderExtended = new Models.PortableExecutable.MenuHeaderExtended();
var menuHeaderExtended = new SabreTools.Models.PortableExecutable.MenuHeaderExtended();
menuHeaderExtended.Version = entry.Data.ReadUInt16(ref offset);
menuHeaderExtended.Offset = entry.Data.ReadUInt16(ref offset);
@@ -968,7 +968,7 @@ namespace BinaryObjectScanner.Builders
#region Extended dialog item templates
var extendedMenuItems = new List<Models.PortableExecutable.MenuItemExtended>();
var extendedMenuItems = new List<SabreTools.Models.PortableExecutable.MenuItemExtended>();
if (offset != 0)
{
@@ -976,12 +976,12 @@ namespace BinaryObjectScanner.Builders
while (offset < entry.Data.Length)
{
var extendedMenuItem = new Models.PortableExecutable.MenuItemExtended();
var extendedMenuItem = new SabreTools.Models.PortableExecutable.MenuItemExtended();
extendedMenuItem.ItemType = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.State = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.ItemType = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.State = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.ID = entry.Data.ReadUInt32(ref offset);
extendedMenuItem.Flags = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.Flags = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
extendedMenuItem.MenuText = entry.Data.ReadString(ref offset, Encoding.Unicode);
// Align to the DWORD boundary if we're not at the end
@@ -1003,7 +1003,7 @@ namespace BinaryObjectScanner.Builders
{
#region Menu header
var menuHeader = new Models.PortableExecutable.MenuHeader();
var menuHeader = new SabreTools.Models.PortableExecutable.MenuHeader();
menuHeader.Version = entry.Data.ReadUInt16(ref offset);
menuHeader.HeaderSize = entry.Data.ReadUInt16(ref offset);
@@ -1014,26 +1014,26 @@ namespace BinaryObjectScanner.Builders
#region Menu items
var menuItems = new List<Models.PortableExecutable.MenuItem>();
var menuItems = new List<SabreTools.Models.PortableExecutable.MenuItem>();
while (offset < entry.Data.Length)
{
var menuItem = new Models.PortableExecutable.MenuItem();
var menuItem = new SabreTools.Models.PortableExecutable.MenuItem();
// Determine if this is a popup
int flagsOffset = offset;
var initialFlags = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt16(ref flagsOffset);
if (initialFlags.HasFlag(Models.PortableExecutable.MenuFlags.MF_POPUP))
var initialFlags = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt16(ref flagsOffset);
if (initialFlags.HasFlag(SabreTools.Models.PortableExecutable.MenuFlags.MF_POPUP))
{
menuItem.PopupItemType = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupState = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupItemType = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupState = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupID = entry.Data.ReadUInt32(ref offset);
menuItem.PopupResInfo = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupResInfo = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt32(ref offset);
menuItem.PopupMenuText = entry.Data.ReadString(ref offset, Encoding.Unicode);
}
else
{
menuItem.NormalResInfo = (Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt16(ref offset);
menuItem.NormalResInfo = (SabreTools.Models.PortableExecutable.MenuFlags)entry.Data.ReadUInt16(ref offset);
menuItem.NormalMenuText = entry.Data.ReadString(ref offset, Encoding.Unicode);
}
@@ -1060,7 +1060,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a message table resource</param>
/// <returns>A filled message table resource on success, null on error</returns>
public static Models.PortableExecutable.MessageResourceData AsMessageResourceData(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.MessageResourceData AsMessageResourceData(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -1070,17 +1070,17 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var messageResourceData = new Models.PortableExecutable.MessageResourceData();
var messageResourceData = new SabreTools.Models.PortableExecutable.MessageResourceData();
// Message resource blocks
messageResourceData.NumberOfBlocks = entry.Data.ReadUInt32(ref offset);
if (messageResourceData.NumberOfBlocks > 0)
{
var messageResourceBlocks = new List<Models.PortableExecutable.MessageResourceBlock>();
var messageResourceBlocks = new List<SabreTools.Models.PortableExecutable.MessageResourceBlock>();
for (int i = 0; i < messageResourceData.NumberOfBlocks; i++)
{
var messageResourceBlock = new Models.PortableExecutable.MessageResourceBlock();
var messageResourceBlock = new SabreTools.Models.PortableExecutable.MessageResourceBlock();
messageResourceBlock.LowId = entry.Data.ReadUInt32(ref offset);
messageResourceBlock.HighId = entry.Data.ReadUInt32(ref offset);
@@ -1095,7 +1095,7 @@ namespace BinaryObjectScanner.Builders
// Message resource entries
if (messageResourceData.Blocks != null && messageResourceData.Blocks.Length != 0)
{
var messageResourceEntries = new Dictionary<uint, Models.PortableExecutable.MessageResourceEntry>();
var messageResourceEntries = new Dictionary<uint, SabreTools.Models.PortableExecutable.MessageResourceEntry>();
for (int i = 0; i < messageResourceData.Blocks.Length; i++)
{
@@ -1104,7 +1104,7 @@ namespace BinaryObjectScanner.Builders
for (uint j = messageResourceBlock.LowId; j <= messageResourceBlock.HighId; j++)
{
var messageResourceEntry = new Models.PortableExecutable.MessageResourceEntry();
var messageResourceEntry = new SabreTools.Models.PortableExecutable.MessageResourceEntry();
messageResourceEntry.Length = entry.Data.ReadUInt16(ref offset);
messageResourceEntry.Flags = entry.Data.ReadUInt16(ref offset);
@@ -1128,7 +1128,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a string table resource</param>
/// <returns>A filled string table resource on success, null on error</returns>
public static Dictionary<int, string> AsStringTable(this Models.PortableExecutable.ResourceDataEntry entry)
public static Dictionary<int, string> AsStringTable(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -1171,7 +1171,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="entry">Resource data entry to parse into a version info resource</param>
/// <returns>A filled version info resource on success, null on error</returns>
public static Models.PortableExecutable.VersionInfo AsVersionInfo(this Models.PortableExecutable.ResourceDataEntry entry)
public static SabreTools.Models.PortableExecutable.VersionInfo AsVersionInfo(this SabreTools.Models.PortableExecutable.ResourceDataEntry entry)
{
// If we have an invalid entry, just skip
if (entry?.Data == null)
@@ -1181,11 +1181,11 @@ namespace BinaryObjectScanner.Builders
int offset = 0;
// Create the output object
var versionInfo = new Models.PortableExecutable.VersionInfo();
var versionInfo = new SabreTools.Models.PortableExecutable.VersionInfo();
versionInfo.Length = entry.Data.ReadUInt16(ref offset);
versionInfo.ValueLength = entry.Data.ReadUInt16(ref offset);
versionInfo.ResourceType = (Models.PortableExecutable.VersionResourceType)entry.Data.ReadUInt16(ref offset);
versionInfo.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)entry.Data.ReadUInt16(ref offset);
versionInfo.Key = entry.Data.ReadString(ref offset, Encoding.Unicode);
if (versionInfo.Key != "VS_VERSION_INFO")
return null;
@@ -1196,7 +1196,7 @@ namespace BinaryObjectScanner.Builders
// Read fixed file info
if (versionInfo.ValueLength > 0)
{
var fixedFileInfo = new Models.PortableExecutable.FixedFileInfo();
var fixedFileInfo = new SabreTools.Models.PortableExecutable.FixedFileInfo();
fixedFileInfo.Signature = entry.Data.ReadUInt32(ref offset);
if (fixedFileInfo.Signature != 0xFEEF04BD)
return null;
@@ -1207,10 +1207,10 @@ namespace BinaryObjectScanner.Builders
fixedFileInfo.ProductVersionMS = entry.Data.ReadUInt32(ref offset);
fixedFileInfo.ProductVersionLS = entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileFlagsMask = entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileFlags = (Models.PortableExecutable.FixedFileInfoFlags)(entry.Data.ReadUInt32(ref offset) & fixedFileInfo.FileFlagsMask);
fixedFileInfo.FileOS = (Models.PortableExecutable.FixedFileInfoOS)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileType = (Models.PortableExecutable.FixedFileInfoFileType)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileSubtype = (Models.PortableExecutable.FixedFileInfoFileSubtype)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileFlags = (SabreTools.Models.PortableExecutable.FixedFileInfoFlags)(entry.Data.ReadUInt32(ref offset) & fixedFileInfo.FileFlagsMask);
fixedFileInfo.FileOS = (SabreTools.Models.PortableExecutable.FixedFileInfoOS)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileType = (SabreTools.Models.PortableExecutable.FixedFileInfoFileType)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileSubtype = (SabreTools.Models.PortableExecutable.FixedFileInfoFileSubtype)entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileDateMS = entry.Data.ReadUInt32(ref offset);
fixedFileInfo.FileDateLS = entry.Data.ReadUInt32(ref offset);
versionInfo.Value = fixedFileInfo;
@@ -1275,16 +1275,16 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into a string file info</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled string file info resource on success, null on error</returns>
private static Models.PortableExecutable.StringFileInfo AsStringFileInfo(byte[] data, ref int offset)
private static SabreTools.Models.PortableExecutable.StringFileInfo AsStringFileInfo(byte[] data, ref int offset)
{
var stringFileInfo = new Models.PortableExecutable.StringFileInfo();
var stringFileInfo = new SabreTools.Models.PortableExecutable.StringFileInfo();
// Cache the initial offset
int currentOffset = offset;
stringFileInfo.Length = data.ReadUInt16(ref offset);
stringFileInfo.ValueLength = data.ReadUInt16(ref offset);
stringFileInfo.ResourceType = (Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringFileInfo.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringFileInfo.Key = data.ReadString(ref offset, Encoding.Unicode);
if (stringFileInfo.Key != "StringFileInfo")
{
@@ -1299,14 +1299,14 @@ namespace BinaryObjectScanner.Builders
stringFileInfo.Padding = data.ReadByte(ref offset);
}
var stringFileInfoChildren = new List<Models.PortableExecutable.StringTable>();
var stringFileInfoChildren = new List<SabreTools.Models.PortableExecutable.StringTable>();
while ((offset - currentOffset) < stringFileInfo.Length)
{
var stringTable = new Models.PortableExecutable.StringTable();
var stringTable = new SabreTools.Models.PortableExecutable.StringTable();
stringTable.Length = data.ReadUInt16(ref offset);
stringTable.ValueLength = data.ReadUInt16(ref offset);
stringTable.ResourceType = (Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringTable.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringTable.Key = data.ReadString(ref offset, Encoding.Unicode);
// Align to the DWORD boundary if we're not at the end
@@ -1316,14 +1316,14 @@ namespace BinaryObjectScanner.Builders
stringTable.Padding = data.ReadByte(ref offset);
}
var stringTableChildren = new List<Models.PortableExecutable.StringData>();
var stringTableChildren = new List<SabreTools.Models.PortableExecutable.StringData>();
while ((offset - currentOffset) < stringTable.Length)
{
var stringData = new Models.PortableExecutable.StringData();
var stringData = new SabreTools.Models.PortableExecutable.StringData();
stringData.Length = data.ReadUInt16(ref offset);
stringData.ValueLength = data.ReadUInt16(ref offset);
stringData.ResourceType = (Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringData.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
stringData.Key = data.ReadString(ref offset, Encoding.Unicode);
// Align to the DWORD boundary if we're not at the end
@@ -1365,16 +1365,16 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Data to parse into a var file info</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>A filled var file info resource on success, null on error</returns>
private static Models.PortableExecutable.VarFileInfo AsVarFileInfo(byte[] data, ref int offset)
private static SabreTools.Models.PortableExecutable.VarFileInfo AsVarFileInfo(byte[] data, ref int offset)
{
var varFileInfo = new Models.PortableExecutable.VarFileInfo();
var varFileInfo = new SabreTools.Models.PortableExecutable.VarFileInfo();
// Cache the initial offset
int initialOffset = offset;
varFileInfo.Length = data.ReadUInt16(ref offset);
varFileInfo.ValueLength = data.ReadUInt16(ref offset);
varFileInfo.ResourceType = (Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
varFileInfo.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
varFileInfo.Key = data.ReadString(ref offset, Encoding.Unicode);
if (varFileInfo.Key != "VarFileInfo")
return null;
@@ -1386,14 +1386,14 @@ namespace BinaryObjectScanner.Builders
varFileInfo.Padding = data.ReadByte(ref offset);
}
var varFileInfoChildren = new List<Models.PortableExecutable.VarData>();
var varFileInfoChildren = new List<SabreTools.Models.PortableExecutable.VarData>();
while ((offset - initialOffset) < varFileInfo.Length)
{
var varData = new Models.PortableExecutable.VarData();
var varData = new SabreTools.Models.PortableExecutable.VarData();
varData.Length = data.ReadUInt16(ref offset);
varData.ValueLength = data.ReadUInt16(ref offset);
varData.ResourceType = (Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
varData.ResourceType = (SabreTools.Models.PortableExecutable.VersionResourceType)data.ReadUInt16(ref offset);
varData.Key = data.ReadString(ref offset, Encoding.Unicode);
if (varData.Key != "Translation")
{

8
BinaryObjectScanner.Builders/GCF.cs
View File

@@ -1,8 +1,8 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.GCF;
using BinaryObjectScanner.Utilities;
using SabreTools.Models.GCF;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life Game Cache on success, null on error</returns>
public static Models.GCF.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.GCF.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life Game Cache on success, null on error</returns>
public static Models.GCF.File ParseFile(Stream data)
public static SabreTools.Models.GCF.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Half-Life Game Cache to fill
var file = new Models.GCF.File();
var file = new SabreTools.Models.GCF.File();
#region Header

4
BinaryObjectScanner.Builders/InstallShieldCabinet.cs
View File

@@ -1,9 +1,9 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.InstallShieldCabinet;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.InstallShieldCabinet.Constants;
using SabreTools.Models.InstallShieldCabinet;
using static SabreTools.Models.InstallShieldCabinet.Constants;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/LinearExecutable.cs
View File

@@ -1,9 +1,9 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.LinearExecutable;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.LinearExecutable.Constants;
using SabreTools.Models.LinearExecutable;
using static SabreTools.Models.LinearExecutable.Constants;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/MSDOS.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.MSDOS;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.MSDOS.Constants;
using SabreTools.Models.MSDOS;
using static SabreTools.Models.MSDOS.Constants;
namespace BinaryObjectScanner.Builders
{

8
BinaryObjectScanner.Builders/MicrosoftCabinet.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.MicrosoftCabinet;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.MicrosoftCabinet.Constants;
using SabreTools.Models.MicrosoftCabinet;
using static SabreTools.Models.MicrosoftCabinet.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -243,9 +243,9 @@ namespace BinaryObjectScanner.Builders
file.FolderIndex = (FolderIndex)data.ReadUInt16();
file.Date = data.ReadUInt16();
file.Time = data.ReadUInt16();
file.Attributes = (Models.MicrosoftCabinet.FileAttributes)data.ReadUInt16();
file.Attributes = (SabreTools.Models.MicrosoftCabinet.FileAttributes)data.ReadUInt16();
if (file.Attributes.HasFlag(Models.MicrosoftCabinet.FileAttributes.NAME_IS_UTF))
if (file.Attributes.HasFlag(SabreTools.Models.MicrosoftCabinet.FileAttributes.NAME_IS_UTF))
file.Name = data.ReadString(Encoding.Unicode);
else
file.Name = data.ReadString(Encoding.ASCII);

4
BinaryObjectScanner.Builders/MoPaQ.cs
View File

@@ -2,9 +2,9 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.MoPaQ;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.MoPaQ.Constants;
using SabreTools.Models.MoPaQ;
using static SabreTools.Models.MoPaQ.Constants;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/N3DS.cs
View File

@@ -1,9 +1,9 @@
using System;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.N3DS;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.N3DS.Constants;
using SabreTools.Models.N3DS;
using static SabreTools.Models.N3DS.Constants;
namespace BinaryObjectScanner.Builders
{

8
BinaryObjectScanner.Builders/NCF.cs
View File

@@ -1,8 +1,8 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.NCF;
using BinaryObjectScanner.Utilities;
using SabreTools.Models.NCF;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life No Cache on success, null on error</returns>
public static Models.NCF.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.NCF.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life No Cache on success, null on error</returns>
public static Models.NCF.File ParseFile(Stream data)
public static SabreTools.Models.NCF.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Half-Life No Cache to fill
var file = new Models.NCF.File();
var file = new SabreTools.Models.NCF.File();
#region Header

4
BinaryObjectScanner.Builders/NewExecutable.cs
View File

@@ -2,9 +2,9 @@
using System.IO;
using System.Linq;
using System.Text;
using BinaryObjectScanner.Models.NewExecutable;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.NewExecutable.Constants;
using SabreTools.Models.NewExecutable;
using static SabreTools.Models.NewExecutable.Constants;
namespace BinaryObjectScanner.Builders
{

2
BinaryObjectScanner.Builders/Nitro.cs
View File

@@ -1,8 +1,8 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.Nitro;
using BinaryObjectScanner.Utilities;
using SabreTools.Models.Nitro;
namespace BinaryObjectScanner.Builders
{

10
BinaryObjectScanner.Builders/PAK.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.PAK;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.PAK.Constants;
using SabreTools.Models.PAK;
using static SabreTools.Models.PAK.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life Package on success, null on error</returns>
public static Models.PAK.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.PAK.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life Package on success, null on error</returns>
public static Models.PAK.File ParseFile(Stream data)
public static SabreTools.Models.PAK.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Half-Life Package to fill
var file = new Models.PAK.File();
var file = new SabreTools.Models.PAK.File();
#region Header

4
BinaryObjectScanner.Builders/PFF.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.PFF;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.PFF.Constants;
using SabreTools.Models.PFF;
using static SabreTools.Models.PFF.Constants;
namespace BinaryObjectScanner.Builders
{

4
BinaryObjectScanner.Builders/PlayJ.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.PlayJ;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.PlayJ.Constants;
using SabreTools.Models.PlayJ;
using static SabreTools.Models.PlayJ.Constants;
namespace BinaryObjectScanner.Builders
{

6
BinaryObjectScanner.Builders/PortableExecutable.cs
View File

@@ -3,9 +3,9 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using BinaryObjectScanner.Models.PortableExecutable;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.PortableExecutable.Constants;
using SabreTools.Models.PortableExecutable;
using static SabreTools.Models.PortableExecutable.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -1303,7 +1303,7 @@ namespace BinaryObjectScanner.Builders
while (data.Position - initialOffset < size && data.Position % 0x200 != 0 && data.Position < data.Length - 1)
{
// If we find the start of an MS-DOS header
if (data.ReadUInt16() == Models.MSDOS.Constants.SignatureUInt16)
if (data.ReadUInt16() == SabreTools.Models.MSDOS.Constants.SignatureUInt16)
{
data.Seek(-2, origin: SeekOrigin.Current);
break;

4
BinaryObjectScanner.Builders/Quantum.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.Quantum;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.Quantum.Constants;
using SabreTools.Models.Quantum;
using static SabreTools.Models.Quantum.Constants;
namespace BinaryObjectScanner.Builders
{

14
BinaryObjectScanner.Builders/SGA.cs
View File

@@ -1,9 +1,9 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.SGA;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.SGA.Constants;
using SabreTools.Models.SGA;
using static SabreTools.Models.SGA.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -17,7 +17,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled SGA on success, null on error</returns>
public static Models.SGA.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.SGA.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -41,7 +41,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled SGA on success, null on error</returns>
public static Models.SGA.File ParseFile(Stream data)
public static SabreTools.Models.SGA.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -55,7 +55,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new SGA to fill
var file = new Models.SGA.File();
var file = new SabreTools.Models.SGA.File();
#region Header
@@ -149,12 +149,12 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Stream to parse</param>
/// <param name="majorVersion">SGA major version</param>
/// <returns>Filled SGA directory on success, null on error</returns>
private static Models.SGA.Directory ParseDirectory(Stream data, ushort majorVersion)
private static SabreTools.Models.SGA.Directory ParseDirectory(Stream data, ushort majorVersion)
{
#region Directory
// Create the appropriate type of directory
Models.SGA.Directory directory;
SabreTools.Models.SGA.Directory directory;
switch (majorVersion)
{
case 4: directory = new Directory4(); break;

10
BinaryObjectScanner.Builders/VBSP.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.VBSP;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.VBSP.Constants;
using SabreTools.Models.VBSP;
using static SabreTools.Models.VBSP.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life 2 Level on success, null on error</returns>
public static Models.VBSP.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.VBSP.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life 2 Level on success, null on error</returns>
public static Models.VBSP.File ParseFile(Stream data)
public static SabreTools.Models.VBSP.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Half-Life 2 Level to fill
var file = new Models.VBSP.File();
var file = new SabreTools.Models.VBSP.File();
#region Header

10
BinaryObjectScanner.Builders/VPK.cs
View File

@@ -1,9 +1,9 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.VPK;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.VPK.Constants;
using SabreTools.Models.VPK;
using static SabreTools.Models.VPK.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -17,7 +17,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Valve Package on success, null on error</returns>
public static Models.VPK.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.VPK.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -41,7 +41,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Valve Package on success, null on error</returns>
public static Models.VPK.File ParseFile(Stream data)
public static SabreTools.Models.VPK.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -55,7 +55,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Valve Package to fill
var file = new Models.VPK.File();
var file = new SabreTools.Models.VPK.File();
#region Header

10
BinaryObjectScanner.Builders/WAD.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.WAD;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.WAD.Constants;
using SabreTools.Models.WAD;
using static SabreTools.Models.WAD.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled Half-Life Texture Package on success, null on error</returns>
public static Models.WAD.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.WAD.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled Half-Life Texture Package on success, null on error</returns>
public static Models.WAD.File ParseFile(Stream data)
public static SabreTools.Models.WAD.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new Half-Life Texture Package to fill
var file = new Models.WAD.File();
var file = new SabreTools.Models.WAD.File();
#region Header

10
BinaryObjectScanner.Builders/XZP.cs
View File

@@ -1,8 +1,8 @@
using System.IO;
using System.Text;
using BinaryObjectScanner.Models.XZP;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.XZP.Constants;
using SabreTools.Models.XZP;
using static SabreTools.Models.XZP.Constants;
namespace BinaryObjectScanner.Builders
{
@@ -16,7 +16,7 @@ namespace BinaryObjectScanner.Builders
/// <param name="data">Byte array to parse</param>
/// <param name="offset">Offset into the byte array</param>
/// <returns>Filled XBox Package File on success, null on error</returns>
public static Models.XZP.File ParseFile(byte[] data, int offset)
public static SabreTools.Models.XZP.File ParseFile(byte[] data, int offset)
{
// If the data is invalid
if (data == null)
@@ -40,7 +40,7 @@ namespace BinaryObjectScanner.Builders
/// </summary>
/// <param name="data">Stream to parse</param>
/// <returns>Filled XBox Package File on success, null on error</returns>
public static Models.XZP.File ParseFile(Stream data)
public static SabreTools.Models.XZP.File ParseFile(Stream data)
{
// If the data is invalid
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
@@ -54,7 +54,7 @@ namespace BinaryObjectScanner.Builders
long initialOffset = data.Position;
// Create a new XBox Package File to fill
var file = new Models.XZP.File();
var file = new SabreTools.Models.XZP.File();
#region Header

10
BinaryObjectScanner.Compression/BinaryObjectScanner.Compression.csproj
View File

@@ -31,13 +31,13 @@
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\BinaryObjectScanner.Utilities\BinaryObjectScanner.Utilities.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="SabreTools.Models" Version="1.1.0" />
<PackageReference Include="SharpCompress" Version="0.32.2" />
<PackageReference Include="SharpZipLib" Version="1.4.1" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\BinaryObjectScanner.Models\BinaryObjectScanner.Models.csproj" />
<ProjectReference Include="..\BinaryObjectScanner.Utilities\BinaryObjectScanner.Utilities.csproj" />
</ItemGroup>
</Project>

4
BinaryObjectScanner.Compression/LZ.cs
View File

@@ -1,9 +1,9 @@
using System.IO;
using System.Linq;
using System.Text;
using BinaryObjectScanner.Models.Compression.LZ;
using BinaryObjectScanner.Utilities;
using static BinaryObjectScanner.Models.Compression.LZ.Constants;
using SabreTools.Models.Compression.LZ;
using static SabreTools.Models.Compression.LZ.Constants;
namespace BinaryObjectScanner.Compression
{

4
BinaryObjectScanner.Compression/LZX/Decompressor.cs
View File

@@ -1,7 +1,7 @@
using System;
using BinaryObjectScanner.Compression.LZX;
using static BinaryObjectScanner.Models.Compression.LZX.Constants;
using static BinaryObjectScanner.Models.MicrosoftCabinet.Constants;
using static SabreTools.Models.Compression.LZX.Constants;
using static SabreTools.Models.MicrosoftCabinet.Constants;
namespace BinaryObjectScanner.Compression.LZX
{

2
BinaryObjectScanner.Compression/LZX/State.cs
View File

@@ -1,4 +1,4 @@
using static BinaryObjectScanner.Models.Compression.LZX.Constants;
using static SabreTools.Models.Compression.LZX.Constants;
namespace BinaryObjectScanner.Compression.LZX
{

4
BinaryObjectScanner.Compression/MSZIP/Decompressor.cs
View File

@@ -1,7 +1,7 @@
using System;
using System.Runtime.InteropServices;
using BinaryObjectScanner.Models.Compression.MSZIP;
using static BinaryObjectScanner.Models.Compression.MSZIP.Constants;
using SabreTools.Models.Compression.MSZIP;
using static SabreTools.Models.Compression.MSZIP.Constants;
namespace BinaryObjectScanner.Compression.MSZIP
{

2
BinaryObjectScanner.Compression/MSZIP/State.cs
View File

@@ -1,4 +1,4 @@
using static BinaryObjectScanner.Models.Compression.MSZIP.Constants;
using static SabreTools.Models.Compression.MSZIP.Constants;
namespace BinaryObjectScanner.Compression.MSZIP
{

4
BinaryObjectScanner.Compression/Quantum/Decompressor.cs
View File

@@ -1,7 +1,7 @@
using System;
using System.Linq;
using BinaryObjectScanner.Models.Compression.Quantum;
using BinaryObjectScanner.Models.MicrosoftCabinet;
using SabreTools.Models.Compression.Quantum;
using SabreTools.Models.MicrosoftCabinet;
namespace BinaryObjectScanner.Compression.Quantum
{

2
BinaryObjectScanner.Compression/Quantum/State.cs
View File

@@ -1,4 +1,4 @@
using BinaryObjectScanner.Models.Compression.Quantum;
using SabreTools.Models.Compression.Quantum;
namespace BinaryObjectScanner.Compression.Quantum
{

4
BinaryObjectScanner.FileType/AACSMediaKeyBlock.cs
View File

@@ -34,11 +34,11 @@ namespace BinaryObjectScanner.FileType
return null;
// Derive the version, if possible
var typeAndVersion = mkb.Records.FirstOrDefault(r => r.RecordType == Models.AACS.RecordType.TypeAndVersion);
var typeAndVersion = mkb.Records.FirstOrDefault(r => r.RecordType == SabreTools.Models.AACS.RecordType.TypeAndVersion);
if (typeAndVersion == null)
return "AACS (Unknown Version)";
else
return $"AACS {(typeAndVersion as Models.AACS.TypeAndVersionRecord).VersionNumber}";
return $"AACS {(typeAndVersion as SabreTools.Models.AACS.TypeAndVersionRecord).VersionNumber}";
}
catch (Exception ex)
{

13
BinaryObjectScanner.Models/AACS/CopyrightRecord.cs
View File

@@ -1,13 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// This record type is undocumented but found in real media key blocks
/// </summary>
public sealed class CopyrightRecord : Record
{
/// <summary>
/// Null-terminated ASCII string representing the copyright
/// </summary>
public string Copyright;
}
}

21
BinaryObjectScanner.Models/AACS/DriveRevocationListEntry.cs
View File

@@ -1,21 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class DriveRevocationListEntry
{
/// <summary>
/// A 2-byte Range value indicates the range of revoked ID’s starting
/// from the ID contained in the record. A value of zero in the Range
/// field indicates that only one ID is being revoked, a value of one
/// in the Range field indicates two ID’s are being revoked, and so on.
/// </summary>
public ushort Range;
/// <summary>
/// A 6-byte Drive ID value identifying the Licensed Drive being revoked
/// (or the first in a range of Licensed Drives being revoked, in the
/// case of a non-zero Range value).
/// </summary>
public byte[] DriveID;
}
}

26
BinaryObjectScanner.Models/AACS/DriveRevocationListRecord.cs
View File

@@ -1,26 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// A properly formatted type 3 or type 4 Media Key Block contains exactly
/// one Drive Revocation List Record. It follows the Host Revocation List
/// Record, although it may not immediately follow it.
///
/// The Drive Revocation List Record is identical to the Host Revocation
/// List Record, except it has type 2016, and it contains Drive Revocation
/// List Entries, not Host Revocation List Entries. The Drive Revocation List
/// Entries refer to Drive IDs in the Drive Certificates.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class DriveRevocationListRecord : Record
{
/// <summary>
/// The total number of Drive Revocation List Entry fields that follow.
/// </summary>
public uint TotalNumberOfEntries;
/// <summary>
/// Revocation list entries
/// </summary>
public DriveRevocationSignatureBlock[] SignatureBlocks;
}
}

17
BinaryObjectScanner.Models/AACS/DriveRevocationSignatureBlock.cs
View File

@@ -1,17 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class DriveRevocationSignatureBlock
{
/// <summary>
/// The number of Drive Revocation List Entry fields in the signature block.
/// </summary>
public uint NumberOfEntries;
/// <summary>
/// A list of 8-byte Host Drive List Entry fields, the length of this
/// list being equal to the number in the signature block.
/// </summary>
public DriveRevocationListEntry[] EntryFields;
}
}

23
BinaryObjectScanner.Models/AACS/EndOfMediaKeyBlockRecord.cs
View File

@@ -1,23 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// A properly formatted MKB shall contain an End of Media Key Block Record.
/// When a device encounters this Record it stops processing the MKB, using
/// whatever Km value it has calculated up to that point as the final Km for
/// that MKB (pending possible checks for correctness of the key, as
/// described previously).
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class EndOfMediaKeyBlockRecord : Record
{
/// <summary>
/// AACS LA’s signature on the data in the Media Key Block up to,
/// but not including, this record. Devices depending on the Version
/// Number in the Type and Version Record must verify the signature.
/// Other devices may ignore the signature data. If any device
/// determines that the signature does not verify or is omitted, it
/// must refuse to use the Media Key.
/// </summary>
public byte[] SignatureData;
}
}

46
BinaryObjectScanner.Models/AACS/Enums.cs
View File

@@ -1,46 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
public enum MediaKeyBlockType : uint
{
/// <summary>
/// (Type 3). This is a normal Media Key Block suitable for being recorded
/// on a AACS Recordable Media. Both Class I and Class II Licensed Products
/// use it to directly calculate the Media Key.
/// </summary>
Type3 = 0x00031003,
/// <summary>
/// (Type 4). This is a Media Key Block that has been designed to use Key
/// Conversion Data (KCD). Thus, it is suitable only for pre-recorded media
/// from which the KCD is derived. Both Class I and Class II Licensed Products
/// use it to directly calculate the Media Key.
/// </summary>
Type4 = 0x00041003,
/// <summary>
/// (Type 10). This is a Class II Media Key Block (one that has the functionality
/// of a Sequence Key Block). This can only be processed by Class II Licensed
/// Products; Class I Licensed Products are revoked in Type 10 Media Key Blocks
/// and cannot process them. This type does not contain the Host Revocation List
/// Record, the Drive Revocation List Record, and the Media Key Data Record, as
/// described in the following sections. It does contain the records shown in
/// Section 3.2.5.2, which are only processed by Class II Licensed Products.
/// </summary>
Type10 = 0x000A1003,
}
public enum RecordType : byte
{
EndOfMediaKeyBlock = 0x02,
ExplicitSubsetDifference = 0x04,
MediaKeyData = 0x05,
SubsetDifferenceIndex = 0x07,
TypeAndVersion = 0x10,
DriveRevocationList = 0x20,
HostRevocationList = 0x21,
VerifyMediaKey = 0x81,
// Not documented
Copyright = 0x7F,
}
}

11
BinaryObjectScanner.Models/AACS/ExplicitSubsetDifferenceRecord.cs
View File

@@ -1,11 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class ExplicitSubsetDifferenceRecord : Record
{
/// <summary>
/// In this record, each subset-difference is encoded with 5 bytes.
/// </summary>
public SubsetDifference[] SubsetDifferences;
}
}

21
BinaryObjectScanner.Models/AACS/HostRevocationListEntry.cs
View File

@@ -1,21 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class HostRevocationListEntry
{
/// <summary>
/// A 2-byte Range value indicates the range of revoked ID’s starting
/// from the ID contained in the record. A value of zero in the Range
/// field indicates that only one ID is being revoked, a value of one
/// in the Range field indicates two ID’s are being revoked, and so on.
/// </summary>
public ushort Range;
/// <summary>
/// A 6-byte Host ID value identifying the host being revoked (or the
/// first in a range of hosts being revoked, in the case of a non-zero
/// Range value).
/// </summary>
public byte[] HostID;
}
}

29
BinaryObjectScanner.Models/AACS/HostRevocationListRecord.cs
View File

@@ -1,29 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// A properly formatted type 3 or type 4 Media Key Block shall have exactly
/// one Host Revocation List Record as its second record. This record provides
/// a list of hosts that have been revoked by the AACS LA. The AACS specification
/// is applicable to PC-based system where a Licensed Drive and PC Host act
/// together as the Recording Device and/or Playback Device for AACS Content.
/// AACS uses a drive-host authentication protocol for the host to verify the
/// integrity of the data received from the Licensed Drive, and for the Licensed
/// Drive to check the validity of the host application. The Type and Version
/// Record and the Host Revocation List Record are guaranteed to be the first two
/// records of a Media Key Block, to make it easier for Licensed Drives to extract
/// this data from an arbitrary Media Key Block.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class HostRevocationListRecord : Record
{
/// <summary>
/// The total number of Host Revocation List Entry fields that follow.
/// </summary>
public uint TotalNumberOfEntries;
/// <summary>
/// Revocation list entries
/// </summary>
public HostRevocationSignatureBlock[] SignatureBlocks;
}
}

17
BinaryObjectScanner.Models/AACS/HostRevocationSignatureBlock.cs
View File

@@ -1,17 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class HostRevocationSignatureBlock
{
/// <summary>
/// The number of Host Revocation List Entry fields in the signature block.
/// </summary>
public uint NumberOfEntries;
/// <summary>
/// A list of 8-byte Host Revocation List Entry fields, the length of this
/// list being equal to the number in the signature block.
/// </summary>
public HostRevocationListEntry[] EntryFields;
}
}

14
BinaryObjectScanner.Models/AACS/MediaKeyBlock.cs
View File

@@ -1,14 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// A Media Key Block is formatted as a sequence of contiguous Records.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class MediaKeyBlock
{
/// <summary>
/// Records
/// </summary>
public Record[] Records { get; set; }
}
}

18
BinaryObjectScanner.Models/AACS/MediaKeyDataRecord.cs
View File

@@ -1,18 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// This record gives the associated encrypted media key data for the
/// subset-differences identified in the Explicit Subset-Difference Record.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class MediaKeyDataRecord : Record
{
/// <summary>
/// Each subset difference has its associated 16 bytes in this
/// record, in the same order it is encountered in the subset-difference
/// record. This 16 bytes is the ciphertext value C in the media
/// key calculation.
/// </summary>
public byte[][] MediaKeyData;
}
}

28
BinaryObjectScanner.Models/AACS/Record.cs
View File

@@ -1,28 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// Each Record begins with a one-byte Record Type field, followed by a
/// three-byte Record Length field.
///
/// The following subsections describe the currently defined Record types,
/// and how a device processes each. All multi-byte integers, including
/// the length field, are “Big Endian”; in other words, the most significant
/// byte comes first in the record.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public abstract class Record
{
/// <summary>
/// The Record Type field value indicates the type of the Record.
/// </summary>
public RecordType RecordType;
/// <summary>
/// The Record Length field value indicates the number of bytes in
/// the Record, including the Record Type and the Record Length
/// fields themselves. Record lengths are always multiples of 4 bytes.
/// </summary>
// <remarks>UInt24 not UInt32</remarks>
public uint RecordLength;
}
}

20
BinaryObjectScanner.Models/AACS/SubsetDifference.cs
View File

@@ -1,20 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class SubsetDifference
{
/// <summary>
/// The mask for u is given by the first byte. That byte is
/// treated as a number, the number of low-order 0-bits in
/// the mask. For example, the value 0x01 denotes a mask of
/// 0xFFFFFFFE; value 0x0A denotes a mask of 0xFFFFFC00.
/// </summary>
public byte Mask;
/// <summary>
/// The last 4 bytes are the uv number, most significant
/// byte first.
/// </summary>
public uint Number;
}
}

26
BinaryObjectScanner.Models/AACS/SubsetDifferenceIndexRecord.cs
View File

@@ -1,26 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// This is a speed-up record which can be ignored by devices not wishing to
/// take advantage of it. It is a lookup table which allows devices to quickly
/// find their subset-difference in the Explicit Subset-Difference record,
/// without processing the entire record. This Subset-Difference Index record
/// is always present, and always precedes the Explicit Subset-Difference record
/// in the MKB, although it does not necessarily immediately precede it.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class SubsetDifferenceIndexRecord : Record
{
/// <summary>
/// The number of devices per index offset.
/// </summary>
public uint Span;
/// <summary>
/// These offsets refer to the offset within the following Explicit
/// Subset-Difference record, with 0 being the start of the record.
/// </summary>
// <remarks>UInt24 not UInt32</remarks>
public uint[] Offsets;
}
}

32
BinaryObjectScanner.Models/AACS/TypeAndVersionRecord.cs
View File

@@ -1,32 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// Devices, except for recording devices which are writing Media Key Block
/// Extensions, may ignore this record. Recording devices shall verify the
/// signature (see End of Media Key Block record) and use the Version Number
/// in this record to determine if a new Media Key BLock Extension is, in
/// fact, more recent than the Media Key Block Extension that is currently
/// on the media.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class TypeAndVersionRecord : Record
{
/// <summary>
/// For AACS applications, the MKBType field is one of three values.
/// It is not an error for a Type 3 Media Key Block to be used for
/// controlling access to AACS Content on pre- recorded media. In
/// this case, the device shall not use the KCD.
/// </summary>
public MediaKeyBlockType MediaKeyBlockType;
/// <summary>
/// The Version Number is a 32-bit unsigned integer. Each time the
/// licensing agency changes the revocation, it increments the version
/// number and inserts the new value in subsequent Media Key Blocks.
/// Thus, larger values indicate more recent Media Key Blocks. The
/// Version Numbers begin at 1; 0 is a special value used for test
/// Media Key Blocks.
/// </summary>
public uint VersionNumber;
}
}

24
BinaryObjectScanner.Models/AACS/VerifyMediaKeyRecord.cs
View File

@@ -1,24 +0,0 @@
namespace BinaryObjectScanner.Models.AACS
{
/// <summary>
/// A properly formatted MKB shall have exactly one Verify Media Key Record
/// as its first record. The presence of the Verify Media Key Record in an MKB
/// is mandatory, but the use of the Record by a device is not mandatory. The
/// device may use the Verify Media Key Record to verify the correctness of a
/// given MKB, or of its processing of it. If everything is correct, the device
/// should observe the condition:
/// [AES_128D(vKm, C]msb_64 == 0x0123456789ABCDEF)]
/// where Km is the Media Key value.
/// </summary>
/// <see href="https://aacsla.com/wp-content/uploads/2019/02/AACS_Spec_Common_Final_0953.pdf"/>
public sealed class VerifyMediaKeyRecord : Record
{
/// <summary>
/// Bytes 4 through 19 of the Record contain the ciphertext value
/// Cv = AES-128E (Km, 0x0123456789ABCDEF || 0xXXXXXXXXXXXXXXXX)
/// where 0xXXXXXXXXXXXXXXXX is an arbitrary 8-byte value, and Km is
/// the correct final Media Key value.
/// </summary>
public byte[] CiphertextValue;
}
}

7
BinaryObjectScanner.Models/BDPlus/Constants.cs
View File

@@ -1,7 +0,0 @@
namespace BinaryObjectScanner.Models.BDPlus
{
public static class Constants
{
public const string SignatureString = "BDSVM_CC";
}
}

46
BinaryObjectScanner.Models/BDPlus/SVM.cs
View File

@@ -1,46 +0,0 @@
namespace BinaryObjectScanner.Models.BDPlus
{
/// <see href="https://github.com/mwgoldsmith/bdplus/blob/master/src/libbdplus/bdsvm/loader.c"/>
public sealed class SVM
{
/// <summary>
/// "BDSVM_CC"
/// </summary>
public string Signature;
/// <summary>
/// 5 bytes of unknown data
/// </summary>
public byte[] Unknown1;
/// <summary>
/// Version year
/// </summary>
public ushort Year;
/// <summary>
/// Version month
/// </summary>
public byte Month;
/// <summary>
/// Version day
/// </summary>
public byte Day;
/// <summary>
/// 4 bytes of unknown data
/// </summary>
public byte[] Unknown2;
/// <summary>
/// Length
/// </summary>
public uint Length;
/// <summary>
/// Length bytes of data
/// </summary>
public byte[] Data;
}
}

19
BinaryObjectScanner.Models/BFPK/Archive.cs
View File

@@ -1,19 +0,0 @@
namespace BinaryObjectScanner.Models.BFPK
{
/// <summary>
/// BFPK custom archive format
/// </summary>
/// <see cref="https://forum.xentax.com/viewtopic.php?t=5102"/>
public sealed class Archive
{
/// <summary>
/// Header
/// </summary>
public Header Header { get; set; }
/// <summary>
/// Files
/// </summary>
public FileEntry[] Files { get; set; }
}
}

11
BinaryObjectScanner.Models/BFPK/Constants.cs
View File

@@ -1,11 +0,0 @@
namespace BinaryObjectScanner.Models.BFPK
{
public static class Constants
{
public static readonly byte[] SignatureBytes = new byte[] { 0x42, 0x46, 0x50, 0x4b };
public const string SignatureString = "BFPK";
public const uint SignatureUInt32 = 0x4b504642;
}
}

34
BinaryObjectScanner.Models/BFPK/FileEntry.cs
View File

@@ -1,34 +0,0 @@
namespace BinaryObjectScanner.Models.BFPK
{
/// <summary>
/// File entry
/// </summary>
/// <see cref="https://forum.xentax.com/viewtopic.php?t=5102"/>
public sealed class FileEntry
{
/// <summary>
/// Name size
/// </summary>
public int NameSize;
/// <summary>
/// Name
/// </summary>
public string Name;
/// <summary>
/// Uncompressed size
/// </summary>
public int UncompressedSize;
/// <summary>
/// Offset
/// </summary>
public int Offset;
/// <summary>
/// Compressed size
/// </summary>
public int CompressedSize;
}
}

27
BinaryObjectScanner.Models/BFPK/Header.cs
View File

@@ -1,27 +0,0 @@
using System.Runtime.InteropServices;
namespace BinaryObjectScanner.Models.BFPK
{
/// <summary>
/// Header
/// </summary>
/// <see cref="https://forum.xentax.com/viewtopic.php?t=5102"/>
[StructLayout(LayoutKind.Sequential)]
public sealed class Header
{
/// <summary>
/// "BFPK"
/// </summary>
public string Magic;
/// <summary>
/// Version
/// </summary>
public int Version;
/// <summary>
/// Files
/// </summary>
public int Files;
}
}

35
BinaryObjectScanner.Models/BMP/BITMAPFILEHEADER.cs
View File

@@ -1,35 +0,0 @@
namespace BinaryObjectScanner.Models.BMP
{
/// <summary>
/// The BITMAPFILEHEADER structure contains information about the type, size,
/// and layout of a file that contains a DIB.
/// </summary>
/// <see href="https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapfileheader"/>
public sealed class BITMAPFILEHEADER
{
/// <summary>
/// The file type; must be BM.
/// </summary>
public ushort Type;
/// <summary>
/// The size, in bytes, of the bitmap file.
/// </summary>
public uint Size;
/// <summary>
/// Reserved; must be zero.
/// </summary>
public ushort Reserved1;
/// <summary>
/// Reserved; must be zero.
/// </summary>
public ushort Reserved2;
/// <summary>
/// The offset, in bytes, from the beginning of the BITMAPFILEHEADER structure to the bitmap bits.
/// </summary>
public uint OffBits;
}
}

94
BinaryObjectScanner.Models/BMP/BITMAPINFOHEADER.cs
View File

@@ -1,94 +0,0 @@
namespace BinaryObjectScanner.Models.BMP
{
/// <summary>
/// The BITMAPINFOHEADER structure contains information about the dimensions and
/// color format of a device-independent bitmap (DIB).
/// </summary>
public sealed class BITMAPINFOHEADER
{
/// <summary>
/// Specifies the number of bytes required by the structure. This value does
/// not include the size of the color table or the size of the color masks,
/// if they are appended to the end of structure.
/// </summary>
public uint Size;
/// <summary>
/// Specifies the width of the bitmap, in pixels.
/// </summary>
public int Width;
/// <summary>
/// Specifies the height of the bitmap, in pixels.
/// - For uncompressed RGB bitmaps, if biHeight is positive, the bitmap is a
/// bottom-up DIB with the origin at the lower left corner. If biHeight is
/// negative, the bitmap is a top-down DIB with the origin at the upper left
/// corner.
/// - For YUV bitmaps, the bitmap is always top-down, regardless of the sign of
/// biHeight. Decoders should offer YUV formats with positive biHeight, but for
/// backward compatibility they should accept YUV formats with either positive
/// or negative biHeight.
/// - For compressed formats, biHeight must be positive, regardless of image orientation.
/// </summary>
public int Height;
/// <summary>
/// Specifies the number of planes for the target device. This value must be set to 1.
/// </summary>
public ushort Planes;
/// <summary>
/// Specifies the number of bits per pixel (bpp). For uncompressed formats, this value
/// is the average number of bits per pixel. For compressed formats, this value is the
/// implied bit depth of the uncompressed image, after the image has been decoded.
/// </summary>
public ushort BitCount;
/// <summary>
/// For compressed video and YUV formats, this member is a FOURCC code, specified as a
/// DWORD in little-endian order. For example, YUYV video has the FOURCC 'VYUY' or
/// 0x56595559. For more information, see FOURCC Codes.
///
/// For uncompressed RGB formats, the following values are possible:
/// - BI_RGB: Uncompressed RGB.
/// - BI_BITFIELDS: Uncompressed RGB with color masks. Valid for 16-bpp and 32-bpp bitmaps.
///
/// Note that BI_JPG and BI_PNG are not valid video formats.
///
/// For 16-bpp bitmaps, if biCompression equals BI_RGB, the format is always RGB 555.
/// If biCompression equals BI_BITFIELDS, the format is either RGB 555 or RGB 565. Use
/// the subtype GUID in the AM_MEDIA_TYPE structure to determine the specific RGB type.
/// </summary>
public uint Compression;
/// <summary>
/// Specifies the size, in bytes, of the image. This can be set to 0 for uncompressed
/// RGB bitmaps.
/// </summary>
public uint SizeImage;
/// <summary>
/// Specifies the horizontal resolution, in pixels per meter, of the target device for
/// the bitmap.
/// </summary>
public int XPelsPerMeter;
/// <summary>
/// Specifies the vertical resolution, in pixels per meter, of the target device for
/// the bitmap.
/// </summary>
public int YPelsPerMeter;
/// <summary>
/// Specifies the number of color indices in the color table that are actually used by
/// the bitmap.
/// </summary>
public uint ClrUsed;
/// <summary>
/// Specifies the number of color indices that are considered important for displaying
/// the bitmap. If this value is zero, all colors are important.
/// </summary>
public uint ClrImportant;
}
}

25
BinaryObjectScanner.Models/BSP/Constants.cs
View File

@@ -1,25 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
public static class Constants
{
/// <summary>
/// Number of lumps in a BSP
/// </summary>
public const int HL_BSP_LUMP_COUNT = 15;
/// <summary>
/// Index for the entities lump
/// </summary>
public const int HL_BSP_LUMP_ENTITIES = 0;
/// <summary>
/// Index for the texture data lump
/// </summary>
public const int HL_BSP_LUMP_TEXTUREDATA = 2;
/// <summary>
/// Number of valid mipmap levels
/// </summary>
public const int HL_BSP_MIPMAP_COUNT = 4;
}
}

29
BinaryObjectScanner.Models/BSP/File.cs
View File

@@ -1,29 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
/// <summary>
/// Half-Life Level
/// </summary>
/// <see href="https://github.com/RavuAlHemio/hllib/blob/master/HLLib/BSPFile.h"/>
public sealed class File
{
/// <summary>
/// Header data
/// </summary>
public Header Header { get; set; }
/// <summary>
/// Lumps
/// </summary>
public Lump[] Lumps { get; set; }
/// <summary>
/// Texture header data
/// </summary>
public TextureHeader TextureHeader { get; set; }
/// <summary>
/// Textures
/// </summary>
public Texture[] Textures { get; set; }
}
}

11
BinaryObjectScanner.Models/BSP/Header.cs
View File

@@ -1,11 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
/// <see href="https://github.com/RavuAlHemio/hllib/blob/master/HLLib/BSPFile.h"/>
public sealed class Header
{
/// <summary>
/// Version
/// </summary>
public uint Version;
}
}

16
BinaryObjectScanner.Models/BSP/Lump.cs
View File

@@ -1,16 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
/// <see href="https://github.com/RavuAlHemio/hllib/blob/master/HLLib/BSPFile.h"/>
public sealed class Lump
{
/// <summary>
/// Offset
/// </summary>
public uint Offset;
/// <summary>
/// Length
/// </summary>
public uint Length;
}
}

41
BinaryObjectScanner.Models/BSP/Texture.cs
View File

@@ -1,41 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
/// <see href="https://github.com/RavuAlHemio/hllib/blob/master/HLLib/BSPFile.h"/>
public sealed class Texture
{
/// <summary>
/// Name
/// </summary>
public string Name;
/// <summary>
/// Width
/// </summary>
public uint Width;
/// <summary>
/// Height
/// </summary>
public uint Height;
/// <summary>
/// Offsets
/// </summary>
public uint[] Offsets;
/// <summary>
/// Texture data
/// </summary>
public byte[] TextureData;
/// <summary>
/// Palette size
/// </summary>
public uint PaletteSize;
/// <summary>
/// Palette data
/// </summary>
public byte[] PaletteData;
}
}

16
BinaryObjectScanner.Models/BSP/TextureHeader.cs
View File

@@ -1,16 +0,0 @@
namespace BinaryObjectScanner.Models.BSP
{
/// <see href="https://github.com/RavuAlHemio/hllib/blob/master/HLLib/BSPFile.h"/>
public sealed class TextureHeader
{
/// <summary>
/// Texture count
/// </summary>
public uint TextureCount;
/// <summary>
/// Offsets
/// </summary>
public uint[] Offsets;
}
}

23
BinaryObjectScanner.Models/BinaryObjectScanner.Models.csproj
View File

@@ -1,23 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net48;net6.0;net7.0</TargetFrameworks>
<RuntimeIdentifiers>win-x86;win-x64;linux-x64;osx-x64</RuntimeIdentifiers>
<Title>BinaryObjectScanner.Models</Title>
<AssemblyName>BinaryObjectScanner.Models</AssemblyName>
<Authors>Matt Nadareski</Authors>
<Product>BurnOutSharp</Product>
<Copyright>Copyright (c)2022 Matt Nadareski</Copyright>
<RepositoryUrl>https://github.com/mnadareski/BurnOutSharp</RepositoryUrl>
<Version>2.8</Version>
<AssemblyVersion>2.8</AssemblyVersion>
<FileVersion>2.8</FileVersion>
<IncludeSource>true</IncludeSource>
<IncludeSymbols>true</IncludeSymbols>
</PropertyGroup>
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
</Project>

92
BinaryObjectScanner.Models/CFB/Binary.cs
View File

@@ -1,92 +0,0 @@
namespace BinaryObjectScanner.Models.CFB
{
/// <summary>
/// Microsoft Compound File Binary (CFB) file format, also known as the
/// Object Linking and Embedding (OLE) or Component Object Model (COM)
/// structured storage compound file implementation binary file format.
/// This structure name can be shortened to compound file.
/// </summary>
/// <see href="https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-CFB/%5bMS-CFB%5d.pdf"/>
public sealed class Binary
{
/// <summary>
/// Compound file header
/// </summary>
public FileHeader Header { get; set; }
/// <summary>
/// The FAT is the main allocator for space within a compound file.
/// Every sector in the file is represented within the FAT in some
/// fashion, including those sectors that are unallocated (free).
/// The FAT is a sector chain that is made up of one or more FAT sectors.
/// </summary>
/// <remarks>
/// If Header Major Version is 3, there MUST be 128 fields specified to fill a 512-byte sector.
///
/// If Header Major Version is 4, there MUST be 1,024 fields specified to fill a 4,096-byte sector
/// </remarks>
public SectorNumber[] FATSectorNumbers { get; set; }
/// <summary>
/// The mini FAT is used to allocate space in the mini stream.
/// The mini stream is divided intosmaller, equal-length sectors,
/// and the sector size that is used for the mini stream is specified
/// from the Compound File Header (64 bytes).
/// </summary>
/// <remarks>
/// If Header Major Version is 3, there MUST be 128 fields specified to fill a 512-byte sector.
///
/// If Header Major Version is 4, there MUST be 1,024 fields specified to fill a 4,096-byte sector
/// </remarks>
public SectorNumber[] MiniFATSectorNumbers { get; set; }
/// <summary>
/// The DIFAT array is used to represent storage of the FAT sectors.
/// The DIFAT is represented by an array of 32-bit sector numbers.
/// The DIFAT array is stored both in the header and in DIFAT sectors.
/// In the header, the DIFAT array occupies 109 entries, and in each
/// DIFAT sector, the DIFAT array occupies the entire sector minus
/// 4 bytes. (The last field is for chaining the DIFAT sector chain.)
/// </summary>
/// <remarks>
/// If Header Major Version is 3, there MUST be 127 fields specified to
/// fill a 512-byte sector minus the "Next DIFAT Sector Location" field.
///
/// If Header Major Version is 4, there MUST be 1,023 fields specified
/// to fill a 4,096-byte sector minus the "Next DIFAT Sector Location" field.
/// </remarks>
public SectorNumber[] DIFATSectorNumbers { get; set; }
/// <summary>
/// The directory entry array is an array of directory entries that
/// are grouped into a directory sector. Each storage object or stream
/// object within a compound file is represented by a single directory
/// entry. The space for the directory sectors that are holding the
/// array is allocated from the FAT.
/// </summary>
/// <remarks>
/// The first entry in the first sector of the directory chain (also
/// referred to as the first element of the directory array, or stream
/// ID #0) is known as the root directory entry, and it is reserved for
/// two purposes. First, it provides a root parent for all objects that
/// are stationed at the root of the compound file. Second, its function
/// is overloaded to store the size and starting sector for the mini stream.
///
/// The root directory entry behaves as both a stream and a storage object.
/// The root directory entry's Name field MUST contain the null-terminated
/// string "Root Entry" in Unicode UTF-16.
///
/// The object class GUID (CLSID) that is stored in the root directory
/// entry can be used for COM activation of the document's application.
///
/// The time stamps for the root storage are not maintained in the root
/// directory entry. Rather, the root storage's creation and modification
/// time stamps are normally stored on the file itself in the file system.
///
/// The Creation Time field in the root storage directory entry MUST be
/// all zeroes. The Modified Time field in the root storage directory
/// entry MAY be all zeroes.
/// <remarks>
public DirectoryEntry[] DirectoryEntries { get; set; }
}
}

52
BinaryObjectScanner.Models/CFB/Constants.cs
View File

@@ -1,52 +0,0 @@
using System;
namespace BinaryObjectScanner.Models.CFB
{
public static class Constants
{
public static readonly byte[] SignatureBytes = new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 };
public const ulong SignatureUInt64 = 0xE11AB1A1E011CFD0;
/// <see href="https://devblogs.microsoft.com/setup/identifying-windows-installer-file-types/"/>
#region Class IDs
/// <summary>
/// Installer Package (msi), Merge Module (msm), Patch Creation Properties (pcp)
/// </summary>
public static readonly Guid InstallerPackage = new Guid("000c1084-0000-0000-c000-000000000046");
/// <summary>
/// Patch Package (msp)
/// </summary>
public static readonly Guid PatchPackage = new Guid("000C1086-0000-0000-C000-000000000046");
/// <summary>
/// Transform (mst)
/// </summary>
public static readonly Guid Transform = new Guid("000C1082-0000-0000-C000-000000000046");
#endregion
/// <see href="https://learn.microsoft.com/en-us/windows/win32/stg/predefined-property-set-format-identifiers"/>
#region Property Set Format IDs
/// <summary>
/// The Summary Information Property Set
/// </summary>
public static readonly Guid FMTID_SummaryInformation = new Guid("F29F85E0-4FF9-1068-AB91-08002B27B3D9");
/// <summary>
/// The DocumentSummaryInformation and UserDefined Property Sets
/// </summary>
public static readonly Guid FMTID_DocSummaryInformation = new Guid("D5CDD502-2E9C-101B-9397-08002B2CF9AE");
/// <summary>
/// The DocumentSummaryInformation and UserDefined Property Sets
/// </summary>
public static readonly Guid FMTID_UserDefinedProperties = new Guid("D5CDD505-2E9C-101B-9397-08002B2CF9AE");
#endregion
}
}

133
BinaryObjectScanner.Models/CFB/DirectoryEntry.cs
View File

@@ -1,133 +0,0 @@
using System;
namespace BinaryObjectScanner.Models.CFB
{
/// <see href="https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-CFB/%5bMS-CFB%5d.pdf"/>
public sealed class DirectoryEntry
{
/// <summary>
/// This field MUST contain a Unicode string for the storage or stream
/// name encoded in UTF-16. The name MUST be terminated with a UTF-16
/// terminating null character. Thus, storage and stream names are limited
/// to 32 UTF-16 code points, including the terminating null character.
/// When locating an object in the compound file except for the root
/// storage, the directory entry name is compared by using a special
/// case-insensitive uppercase mapping, described in Red-Black Tree.
/// The following characters are illegal and MUST NOT be part of the
/// name: '/', '\', ':', '!'.
/// </summary>
public string Name;
/// <summary>
/// This field MUST be 0x00, 0x01, 0x02, or 0x05, depending on the
/// actual type of object. All other values are not valid.
/// </summary>
public ushort NameLength;
/// <summary>
/// This field MUST match the length of the Directory Entry Name Unicode
/// string in bytes. The length MUST be a multiple of 2 and include the
/// terminating null character in the count. This length MUST NOT exceed 64,
/// the maximum size of the Directory Entry Name field.
/// </summary>
public ObjectType ObjectType;
/// <summary>
/// This field MUST be 0x00 (red) or 0x01 (black). All other values are not valid.
/// </summary>
public ColorFlag ColorFlag;
/// <summary>
/// This field contains the stream ID of the left sibling. If there
/// is no left sibling, the field MUST be set to NOSTREAM (0xFFFFFFFF).
/// </summary>
public StreamID LeftSiblingID;
/// <summary>
/// This field contains the stream ID of the right sibling. If there
/// is no right sibling, the field MUST be set to NOSTREAM (0xFFFFFFFF).
/// </summary>
public StreamID RightSiblingID;
/// <summary>
/// This field contains the stream ID of a child object. If there is no
/// child object, including all entries for stream objects, the field
/// MUST be set to NOSTREAM (0xFFFFFFFF).
/// </summary>
public StreamID ChildID;
/// <summary>
/// This field contains an object class GUID, if this entry is for a
/// storage object or root storage object. For a stream object, this field
/// MUST be set to all zeroes. A value containing all zeroes in a storage
/// or root storage directory entry is valid, and indicates that no object
/// class is associated with the storage. If an implementation of the file
/// format enables applications to create storage objects without explicitly
/// setting an object class GUID, it MUST write all zeroes by default. If
/// this value is not all zeroes, the object class GUID can be used as a
/// parameter to start applications.
/// </summary>
public Guid CLSID;
/// <summary>
/// This field contains the user-defined flags if this entry is for a storage
/// object or root storage object. For a stream object, this field SHOULD be
/// set to all zeroes because many implementations provide no way for
/// applications to retrieve state bits from a stream object. If an
/// implementation of the file format enables applications to create storage
/// objects without explicitly setting state bits, it MUST write all zeroes
/// by default.
/// </summary>
public uint StateBits;
/// <summary>
/// This field contains the creation time for a storage object, or all zeroes
/// to indicate that the creation time of the storage object was not recorded.
/// The Windows FILETIME structure is used to represent this field in UTC.
/// For a stream object, this field MUST be all zeroes. For a root storage
/// object, this field MUST be all zeroes, and the creation time is retrieved
/// or set on the compound file itself.
/// </summary>
public ulong CreationTime;
/// <summary>
/// This field contains the modification time for a storage object, or all
/// zeroes to indicate that the modified time of the storage object was not
/// recorded. The Windows FILETIME structure is used to represent this field
/// in UTC. For a stream object, this field MUST be all zeroes. For a root
/// storage object, this field MAY<2> be set to all zeroes, and the modified
/// time is retrieved or set on the compound file itself.
/// </summary>
public ulong ModifiedTime;
/// <summary>
/// This field contains the first sector location if this is a stream object.
/// For a root storage object, this field MUST contain the first sector of the
/// mini stream, if the mini stream exists. For a storage object, this field MUST
/// be set to all zeroes.
/// </summary>
public uint StartingSectorLocation;
/// <summary>
/// This 64-bit integer field contains the size of the user-defined data if this
/// is a stream object. For a root storage object, this field contains the size
/// of the mini stream. For a storage object, this field MUST be set to all zeroes.
/// </summary>
/// <remarks>
/// For a version 3 compound file 512-byte sector size, the value of this field MUST
/// be less than or equal to 0x80000000. (Equivalently, this requirement can be stated:
/// the size of a stream or of the mini stream in a version 3 compound file MUST be
/// less than or equal to 2 gigabytes (GB).) Note that as a consequence of this
/// requirement, the most significant 32 bits of this field MUST be zero in a version
/// 3 compound file. However, implementers should be aware that some older
/// implementations did not initialize the most significant 32 bits of this field,
/// and these bits might therefore be nonzero in files that are otherwise valid
/// version 3 compound files. Although this document does not normatively specify
/// parser behavior, it is recommended that parsers ignore the most significant 32 bits
/// of this field in version 3 compound files, treating it as if its value were zero,
/// unless there is a specific reason to do otherwise (for example, a parser whose
/// purpose is to verify the correctness of a compound file).
/// </remarks>
public ulong StreamSize;
}
}

474
BinaryObjectScanner.Models/CFB/Enums.cs
View File

@@ -1,474 +0,0 @@
namespace BinaryObjectScanner.Models.CFB
{
public enum ColorFlag : byte
{
Red = 0x00,
Black = 0x01,
}
public enum ObjectType : byte
{
Unknown = 0x00,
StorageObject = 0x01,
StreamObject = 0x02,
RootStorageObject = 0x05,
}
public enum SectorNumber : uint
{
/// <summary>
/// Regular sector number.
/// </summary>
REGSECT = 0x00000000, // 0x00000000 - 0xFFFFFFF9
/// <summary>
/// Maximum regular sector number.
/// </summary>
MAXREGSECT = 0xFFFFFFFA,
/// <summary>
/// Reserved for future use.
/// </summary>
NotApplicable = 0xFFFFFFFB,
/// <summary>
/// Specifies a DIFAT sector in the FAT.
/// </summary>
DIFSECT = 0xFFFFFFFC,
/// <summary>
/// Specifies a FAT sector in the FAT.
/// </summary>
FATSECT = 0xFFFFFFFD,
/// <summary>
/// End of a linked chain of sectors.
/// </summary>
ENDOFCHAIN = 0xFFFFFFFE,
/// <summary>
/// Specifies an unallocated sector in the FAT, Mini FAT, or DIFAT.
/// </summary>
FREESECT = 0xFFFFFFFF,
}
public enum StreamID : uint
{
/// <summary>
/// Regular stream ID to identify the directory entry.
/// </summary>
REGSID = 0x00000000, // 0x00000000 - 0xFFFFFFF9
/// <summary>
/// Maximum regular stream ID.
/// </summary>
MAXREGSID = 0xFFFFFFFA,
/// <summary>
/// Terminator or empty pointer.
/// </summary>
NOSTREAM = 0xFFFFFFFF,
}
/// <see href="https://learn.microsoft.com/en-us/windows/win32/stg/the-summary-information-property-set"/>
public enum SummaryInformationProperty : uint
{
/// <summary>
/// Title
/// </summary>
PIDSI_TITLE = 0x00000002,
/// <summary>
/// Subject
/// </summary>
PIDSI_SUBJECT = 0x00000003,
/// <summary>
/// Author
/// </summary>
PIDSI_AUTHOR = 0x00000004,
/// <summary>
/// Keywords
/// </summary>
PIDSI_KEYWORDS = 0x00000005,
/// <summary>
/// Comments
/// </summary>
PIDSI_COMMENTS = 0x00000006,
/// <summary>
/// Template
/// </summary>
PIDSI_TEMPLATE = 0x00000007,
/// <summary>
/// Last Saved By
/// </summary>
PIDSI_LASTAUTHOR = 0x00000008,
/// <summary>
/// Revision Number
/// </summary>
PIDSI_REVNUMBER = 0x00000009,
/// <summary>
/// Total Editing Time
/// </summary>
PIDSI_EDITTIME = 0x0000000A,
/// <summary>
/// Last Printed
/// </summary>
PIDSI_LASTPRINTED = 0x0000000B,
/// <summary>
/// Create Time/Date
/// </summary>
PIDSI_CREATE_DTM = 0x0000000C,
/// <summary>
/// Last saved Time/Date
/// </summary>
PIDSI_LASTSAVE_DTM = 0x0000000D,
/// <summary>
/// Number of Pages
/// </summary>
PIDSI_PAGECOUNT = 0x0000000E,
/// <summary>
/// Number of Words
/// </summary>
PIDSI_WORDCOUNT = 0x0000000F,
/// <summary>
/// Number of Characters
/// </summary>
PIDSI_CHARCOUNT = 0x00000010,
/// <summary>
/// Thumbnail
/// </summary>
PIDSI_THUMBNAIL = 0x00000011,
/// <summary>
/// Name of Creating Application
/// </summary>
PIDSI_APPNAME = 0x00000012,
/// <summary>
/// Security
/// </summary>
PIDSI_SECURITY = 0x00000013,
}
/// <remarks>Also includes the DocumentSummaryInformation set</remarks>
/// <see href="https://learn.microsoft.com/en-us/windows/win32/stg/the-documentsummaryinformation-and-userdefined-property-sets"/>
public enum UserDefinedProperty : uint
{
/// <summary>
/// Category - A text string typed by the user that indicates what
/// category the file belongs to (memo, proposal, and so on). It
/// is useful for finding files of same type.
/// </summary>
PIDDSI_CATEGORY = 0x00000002,
/// <summary>
/// PresentationTarget - Target format for presentation (35mm,
/// printer, video, and so on).
/// </summary>
PIDDSI_PRESFORMAT = 0x00000003,
/// <summary>
/// Bytes - Number of bytes.
/// </summary>
PIDDSI_BYTECOUNT = 0x00000004,
/// <summary>
/// Lines - Number of lines.
/// </summary>
PIDDSI_LINECOUNT = 0x00000005,
/// <summary>
/// Paragraphs - Number of paragraphs.
/// </summary>
PIDDSI_PARCOUNT = 0x00000006,
/// <summary>
/// Slides - Number of slides.
/// </summary>
PIDDSI_SLIDECOUNT = 0x00000007,
/// <summary>
/// Notes - Number of pages that contain notes.
/// </summary>
PIDDSI_NOTECOUNT = 0x00000008,
/// <summary>
/// HiddenSlides - Number of slides that are hidden.
/// </summary>
PIDDSI_HIDDENCOUNT = 0x00000009,
/// <summary>
/// MMClips - Number of sound or video clips.
/// </summary>
PIDDSI_MMCLIPCOUNT = 0x0000000A,
/// <summary>
/// ScaleCrop - Set to True (-1) when scaling of the thumbnail
/// is desired. If not set, cropping is desired.
/// </summary>
PIDDSI_SCALE = 0x0000000B,
/// <summary>
/// HeadingPairs - Internally used property indicating the
/// grouping of different document parts and the number of
/// items in each group. The titles of the document parts are
/// stored in the TitlesofParts property. The HeadingPairs
/// property is stored as a vector of variants, in repeating
/// pairs of VT_LPSTR (or VT_LPWSTR) and VT_I4 values. The
/// VT_LPSTR value represents a heading name, and the VT_I4
/// value indicates the count of document parts under that heading.
/// </summary>
PIDDSI_HEADINGPAIR = 0x0000000C,
/// <summary>
/// TitlesofParts - Names of document parts.
/// </summary>
PIDDSI_DOCPARTS = 0x0000000D,
/// <summary>
/// Manager - Manager of the project.
/// </summary>
PIDDSI_MANAGER = 0x0000000E,
/// <summary>
/// Company - Company name.
/// </summary>
PIDDSI_COMPANY = 0x0000000F,
/// <summary>
/// LinksUpToDate - Boolean value to indicate whether the custom
/// links are hampered by excessive noise, for all applications.
/// </summary>
PIDDSI_LINKSDIRTY = 0x00000010,
}
/// <see href="https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-oaut/3fe7db9f-5803-4dc4-9d14-5425d3f5461f"/>
public enum VariantType : ushort
{
/// <summary>
/// The type of the contained field is undefined. When this flag is
/// specified, the VARIANT MUST NOT contain a data field.
/// </summary>
VT_EMPTY = 0x0000,
/// <summary>
/// The type of the contained field is NULL. When this flag is
/// specified, the VARIANT MUST NOT contain a data field.
/// </summary>
VT_NULL = 0x0001,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 2-byte signed integer.
/// </summary>
VT_I2 = 0x0002,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 4-byte signed integer.
/// </summary>
VT_I4 = 0x0003,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 4-byte IEEE floating-point number.
/// </summary>
VT_R4 = 0x0004,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be an 8-byte IEEE floating-point number.
/// </summary>
VT_R8 = 0x0005,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be CURRENCY.
/// </summary>
VT_CY = 0x0006,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be DATE.
/// </summary>
VT_DATE = 0x0007,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be BSTR.
/// </summary>
VT_BSTR = 0x0008,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a pointer to IDispatch.
/// </summary>
VT_DISPATCH = 0x0009,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be HRESULT.
/// </summary>
VT_ERROR = 0x000A,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be VARIANT_BOOL.
/// </summary>
VT_BOOL = 0x000B,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be VARIANT. It MUST appear with the bit flag VT_BYREF.
/// </summary>
VT_VARIANT = 0x000C,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a pointer to IUnknown.
/// </summary>
VT_UNKNOWN = 0x000D,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be DECIMAL.
/// </summary>
VT_DECIMAL = 0x000E,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 1-byte integer.
/// </summary>
VT_I1 = 0x0010,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 1-byte unsigned integer.
/// </summary>
VT_UI1 = 0x0011,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 2-byte unsigned integer.
/// </summary>
VT_UI2 = 0x0012,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 4-byte unsigned integer.
/// </summary>
VT_UI4 = 0x0013,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be an 8-byte signed integer.
/// </summary>
VT_I8 = 0x0014,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be an 8-byte unsigned integer.
/// </summary>
VT_UI8 = 0x0015,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 4-byte signed integer.
/// </summary>
VT_INT = 0x0016,
/// <summary>
/// Either the specified type, or the type of the element or contained
/// field MUST be a 4-byte unsigned integer.
/// </summary>
VT_UINT = 0x0017,
/// <summary>
/// The specified type MUST be void.
/// </summary>
VT_VOID = 0x0018,
/// <summary>
/// The specified type MUST be HRESULT.
/// </summary>
VT_HRESULT = 0x0019,
/// <summary>
/// The specified type MUST be a unique pointer.
/// </summary>
VT_PTR = 0x001A,
/// <summary>
/// The specified type MUST be SAFEARRAY.
/// </summary>
VT_SAFEARRAY = 0x001B,
/// <summary>
/// The specified type MUST be a fixed-size array.
/// </summary>
VT_CARRAY = 0x001C,
/// <summary>
/// The specified type MUST be user defined.
/// </summary>
VT_USERDEFINED = 0x001D,
/// <summary>
/// The specified type MUST be a NULL-terminated string.
/// </summary>
VT_LPSTR = 0x001E,
/// <summary>
/// The specified type MUST be a zero-terminated string of
/// UNICODE characters.
/// </summary>
VT_LPWSTR = 0x001F,
/// <summary>
/// The type of the element or contained field MUST be a BRECORD.
/// </summary>
VT_RECORD = 0x0024,
/// <summary>
/// The specified type MUST be either a 4-byte or an 8-byte signed
/// integer. The size of the integer is platform specific and
/// determines the system pointer size value.
/// </summary>
VT_INT_PTR = 0x0025,
/// <summary>
/// The specified type MUST be either a 4 byte or an 8 byte unsigned
/// integer. The size of the integer is platform specific and
/// determines the system pointer size value
/// </summary>
VT_UINT_PTR = 0x0026,
/// <summary>
/// The type of the element or contained field MUST be a SAFEARRAY.
/// </summary>
VT_ARRAY = 0x2000,
/// <summary>
/// The type of the element or contained field MUST be a pointer to
/// one of the types listed in the previous rows of this table. If
/// present, this bit flag MUST appear in a VARIANT discriminant
/// with one of the previous flags.
/// </summary>
VT_BYREF = 0x4000
}
}

127
BinaryObjectScanner.Models/CFB/FileHeader.cs
View File

@@ -1,127 +0,0 @@
using System;
namespace BinaryObjectScanner.Models.CFB
{
/// <see href="https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-CFB/%5bMS-CFB%5d.pdf"/>
public sealed class FileHeader
{
/// <summary>
/// Iddentification signature for the compound file structure, and MUST be
/// set to the value 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1.
/// </summary>
public ulong Signature;
/// <summary>
/// Reserved and unused class ID that MUST be set to all zeroes (CLSID_NULL)
/// </summary>
public Guid CLSID;
/// <summary>
/// Version number for nonbreaking changes. This field SHOULD be set to
/// 0x003E if the major version field is either 0x0003 or 0x0004.
/// </summary>
public ushort MinorVersion;
/// <summary>
/// Version number for breaking changes. This field MUST be set to either
/// 0x0003 (version 3) or 0x0004 (version 4).
/// </summary>
public ushort MajorVersion;
/// <summary>
/// This field MUST be set to 0xFFFE. This field is a byte order mark for
/// all integer fields, specifying little-endian byte order.
/// </summary>
public ushort ByteOrder;
/// <summary>
/// This field MUST be set to 0x0009, or 0x000c, depending on the Major
/// Version field. This field specifies the sector size of the compound file
/// as a power of 2.
///
/// If Major Version is 3, the Sector Shift MUST be 0x0009, specifying a
/// sector size of 512 bytes.
///
/// If Major Version is 4, the Sector Shift MUST be 0x000C, specifying a
/// sector size of 4096 bytes.
/// </summary>
public ushort SectorShift;
/// <summary>
/// This field MUST be set to 0x0006. This field specifies the sector size
/// of the Mini Stream as a power of 2. The sector size of the Mini Stream
/// MUST be 64 bytes.
/// </summary>
public ushort MiniSectorShift;
/// <summary>
/// This field MUST be set to all zeroes.
/// </summary>
public byte[] Reserved;
/// <summary>
/// This integer field contains the count of the number of directory sectors
/// in the compound file.
///
/// If Major Version is 3, the Number of Directory Sectors MUST be zero. This
/// field is not supported for version 3 compound files.
/// </summary>
public uint NumberOfDirectorySectors;
/// <summary>
/// This integer field contains the count of the number of FAT sectors in the
/// compound file.
/// </summary>
public uint NumberOfFATSectors;
/// <summary>
/// This integer field contains the starting sector number for the directory stream.
/// </summary>
public uint FirstDirectorySectorLocation;
/// <summary>
/// This integer field MAY contain a sequence number that is incremented every time
/// the compound file is saved by an implementation that supports file transactions.
/// This is the field that MUST be set to all zeroes if file transactions are not
/// implemented.
/// </summary>
public uint TransactionSignatureNumber;
/// <summary>
/// This integer field MUST be set to 0x00001000. This field specifies the maximum
/// size of a user-defined data stream that is allocated from the mini FAT and mini
/// stream, and that cutoff is 4,096 bytes. Any user-defined data stream that is
/// greater than or equal to this cutoff size must be allocated as normal sectors from
/// the FAT.
/// </summary>
public uint MiniStreamCutoffSize;
/// <summary>
/// This integer field contains the starting sector number for the mini FAT.
/// </summary>
public uint FirstMiniFATSectorLocation;
/// <summary>
/// This integer field contains the count of the number of mini FAT sectors in the
/// compound file.
/// </summary>
public uint NumberOfMiniFATSectors;
/// <summary>
/// This integer field contains the starting sector number for the DIFAT.
/// </summary>
public uint FirstDIFATSectorLocation;
/// <summary>
/// This integer field contains the count of the number of DIFAT sectors in the
/// compound file.
/// </summary>
public uint NumberOfDIFATSectors;
/// <summary>
/// This array of 32-bit integer fields contains the first 109 FAT sector
/// locations of the compound file
/// </summary>
public SectorNumber[] DIFAT;
}
}

82
BinaryObjectScanner.Models/CFB/SummaryInformation.cs
View File

@@ -1,82 +0,0 @@
using System;
namespace BinaryObjectScanner.Models.CFB
{
/// <see href="https://github.com/GNOME/msitools/blob/master/libmsi/libmsi-summary-info.c"/>
public sealed class SummaryInformation
{
#region Set Header
/// <summary>
/// This field MUST be set to 0xFFFE. This field is a byte order mark for
/// all integer fields, specifying little-endian byte order.
/// </summary>
public ushort ByteOrder;
/// <summary>
/// Format
/// </summary>
public ushort Format;
/// <summary>
/// Build
/// </summary>
public ushort Build;
/// <summary>
/// Platform ID
/// </summary>
public ushort PlatformID;
/// <summary>
/// CLSID
/// </summary>
public Guid CLSID;
/// <summary>
/// 4 bytes of reserved data
/// </summary>
public byte[] Reserved;
#endregion
#region Format Header
/// <summary>
/// Format ID, should be <see cref="Constants.FMTID_SummaryInformation"/>
/// </summary>
public Guid FormatID;
/// <summary>
/// 16 bytes of unknown data
/// </summary>
public byte[] Unknown;
#endregion
#region Section Header
/// <summary>
/// Location of the section
/// </summary>
public uint Offset;
/// <summary>
/// Section count(?)
/// </summary>
public uint SectionCount;
/// <summary>
/// Property count
/// </summary>
public uint PropertyCount;
/// <summary>
/// Properties
/// </summary>
/// <remarks>Each Variant might be followed by an index and offset value</remarks>
public Variant[] Properties;
#endregion
}
}

45
BinaryObjectScanner.Models/CFB/Variant.cs
View File

@@ -1,45 +0,0 @@
namespace BinaryObjectScanner.Models.CFB
{
/// <summary>
/// VARIANT is a container for a union that can hold many types of data.
/// </summary>
/// <see href="https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-oaut/b2ee2b50-665e-43e6-a92c-8f2a29fd7add"/>
public sealed class Variant
{
/// <summary>
/// MUST be set to the size, in quad words (64 bits), of the structure.
/// </summary>
public uint Size;
/// <summary>
/// MUST be set to 0 and MUST be ignored by the recipient.
/// </summary>
public uint RpcReserved;
/// <summary>
/// MUST be set to one of the values specified with a "V".
/// </summary>
public VariantType VariantType;
/// <summary>
/// MAY be set to 0 and MUST be ignored by the recipient.
/// </summary>
public ushort Reserved1;
/// <summary>
/// MAY be set to 0 and MUST be ignored by the recipient.
/// </summary>
public ushort Reserved2;
/// <summary>
/// MAY be set to 0 and MUST be ignored by the recipient.
/// </summary>
public ushort Reserved3;
/// <summary>
/// MUST contain an instance of the type, according to the value
/// in the <see cref="VariantType"/> field.
/// </summary>
public object Union;
}
}

23
BinaryObjectScanner.Models/Compression/LZ/Constants.cs
View File

@@ -1,23 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZ
{
public static class Constants
{
public const int GETLEN = 2048;
public const int LZ_MAGIC_LEN = 8;
public const int LZ_HEADER_LEN = 14;
public static readonly byte[] MagicBytes = new byte[] { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
public static readonly string MagicString = System.Text.Encoding.ASCII.GetString(MagicBytes);
public const ulong MagicUInt64 = 0x3327f08844445a53;
public const int LZ_TABLE_SIZE = 0x1000;
public const int MAX_LZSTATES = 16;
public const int LZ_MIN_HANDLE = 0x400;
}
}

17
BinaryObjectScanner.Models/Compression/LZ/Enums.cs
View File

@@ -1,17 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZ
{
/// <see href="https://github.com/wine-mirror/wine/blob/master/include/lzexpand.h"/>
public enum LZERROR
{
LZERROR_OK = 1,
LZERROR_NOT_LZ = 0,
LZERROR_BADINHANDLE = -1,
LZERROR_BADOUTHANDLE = -2,
LZERROR_READ = -3,
LZERROR_WRITE = -4,
LZERROR_GLOBALLOC = -5,
LZERROR_GLOBLOCK = -6,
LZERROR_BADVALUE = -7,
LZERROR_UNKNOWNALG = -8,
}
}

17
BinaryObjectScanner.Models/Compression/LZ/FileHeader.cs
View File

@@ -1,17 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZ
{
/// <summary>
/// Format of first 14 byte of LZ compressed file
/// </summary>
/// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/kernel32/lzexpand.c"/>
public sealed class FileHeaader
{
public string Magic;
public byte CompressionType;
public char LastChar;
public uint RealLength;
}
}

72
BinaryObjectScanner.Models/Compression/LZ/State.cs
View File

@@ -1,72 +0,0 @@
using System.IO;
namespace BinaryObjectScanner.Models.Compression.LZ
{
public sealed class State
{
/// <summary>
/// Internal backing stream
/// </summary>
public Stream Source { get; set; }
/// <summary>
/// The last char of the filename for replacement
/// </summary>
public char LastChar { get; set; }
/// <summary>
/// Decompressed length of the file
/// </summary>
public uint RealLength { get; set; }
/// <summary>
/// Position the decompressor currently is
/// </summary>
public uint RealCurrent { get; set; }
/// <summary>
/// Position the user wants to read from
/// </summary>
public uint RealWanted { get; set; }
/// <summary>
/// The rotating LZ table
/// </summary>
public byte[] Table { get; set; }
/// <summary>
/// CURrent TABle ENTry
/// </summary>
public uint CurrentTableEntry { get; set; }
/// <summary>
/// Length and position of current string
/// </summary>
public byte StringLength { get; set; }
/// <summary>
/// From stringtable
/// </summary>
public uint StringPosition { get; set; }
/// <summary>
/// Bitmask within blocks
/// </summary>
public ushort ByteType { get; set; }
/// <summary>
/// GETLEN bytes
/// </summary>
public byte[] Window { get; set; }
/// <summary>
/// Current read
/// </summary>
public uint WindowCurrent { get; set; }
/// <summary>
/// Length last got
/// </summary>
public uint WindowLength { get; set; }
}
}

61
BinaryObjectScanner.Models/Compression/LZX/AlignedOffsetBlock.cs
View File

@@ -1,61 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
/// <summary>
/// An aligned offset block is identical to the verbatim block except for the presence of the aligned offset
/// tree preceding the other trees.
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
public class AlignedOffsetBlock
{
/// <summary>
/// Generic block header
/// </summary>
public BlockHeader Header;
/// <summary>
/// Aligned offset tree
/// </summary>
/// <remarks>8 elements, 3 bits each</remarks>
public byte[] AlignedOffsetTree;
/// <summary>
/// Pretree for first 256 elements of main tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeFirst256;
/// <summary>
/// Path lengths of first 256 elements of main tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsFirst256;
/// <summary>
/// Pretree for remainder of main tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeRemainder;
/// <summary>
/// Path lengths of remaining elements of main tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsRemainder;
/// <summary>
/// Pretree for length tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeLengthTree;
/// <summary>
/// Path lengths of elements in length tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsLengthTree;
// Entry Comments Size
// ---------------------------------------------------------------------------------------
// Token sequence (matches and literals) Specified in section 2.6 Variable
}
}

38
BinaryObjectScanner.Models/Compression/LZX/BlockHeader.cs
View File

@@ -1,38 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
/// <summary>
/// An LZXD block represents a sequence of compressed data that is encoded with the same set of
/// Huffman trees, or a sequence of uncompressed data. There can be one or more LZXD blocks in a
/// compressed stream, each with its own set of Huffman trees. Blocks do not have to start or end on a
/// chunk boundary; blocks can span multiple chunks, or a single chunk can contain multiple blocks. The
/// number of chunks is related to the size of the data being compressed, while the number of blocks is
/// related to how well the data is compressed. The Block Type field, as specified in section 2.3.1.1,
/// indicates which type of block follows, and the Block Size field, as specified in section 2.3.1.2,
/// indicates the number of uncompressed bytes represented by the block. Following the generic block
/// header is a type-specific header that describes the remainder of the block.
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
public class BlockHeader
{
/// <remarks>3 bits</remarks>
public BlockType BlockType;
/// <summary>
/// Block size is the high 8 bits of 24
/// </summary>
/// <remarks>8 bits</remarks>
public byte BlockSizeMSB;
/// <summary>
/// Block size is the middle 8 bits of 24
/// </summary>
/// <remarks>8 bits</remarks>
public byte BlockSizeByte2;
/// <summary>
/// Block size is the low 8 bits of 24
/// </summary>
/// <remarks>8 bits</remarks>
public byte BlocksizeLSB;
}
}

46
BinaryObjectScanner.Models/Compression/LZX/Constants.cs
View File

@@ -1,46 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
public static class Constants
{
/* some constants defined by the LZX specification */
public const int LZX_MIN_MATCH = (2);
public const int LZX_MAX_MATCH = (257);
public const int LZX_NUM_CHARS = (256);
/// <summary>
/// also blocktypes 4-7 invalid
/// </summary>
public const int LZX_BLOCKTYPE_INVALID = (0);
public const int LZX_BLOCKTYPE_VERBATIM = (1);
public const int LZX_BLOCKTYPE_ALIGNED = (2);
public const int LZX_BLOCKTYPE_UNCOMPRESSED = (3);
public const int LZX_PRETREE_NUM_ELEMENTS = (20);
/// <summary>
/// aligned offset tree #elements
/// </summary>
public const int LZX_ALIGNED_NUM_ELEMENTS = (8);
/// <summary>
/// this one missing from spec!
/// </summary>
public const int LZX_NUM_PRIMARY_LENGTHS = (7);
/// <summary>
/// length tree #elements
/// </summary>
public const int LZX_NUM_SECONDARY_LENGTHS = (249);
/* LZX huffman defines: tweak tablebits as desired */
public const int LZX_PRETREE_MAXSYMBOLS = (LZX_PRETREE_NUM_ELEMENTS);
public const int LZX_PRETREE_TABLEBITS = (6);
public const int LZX_MAINTREE_MAXSYMBOLS = (LZX_NUM_CHARS + 50 * 8);
public const int LZX_MAINTREE_TABLEBITS = (12);
public const int LZX_LENGTH_MAXSYMBOLS = (LZX_NUM_SECONDARY_LENGTHS + 1);
public const int LZX_LENGTH_TABLEBITS = (12);
public const int LZX_ALIGNED_MAXSYMBOLS = (LZX_ALIGNED_NUM_ELEMENTS);
public const int LZX_ALIGNED_TABLEBITS = (7);
public const int LZX_LENTABLE_SAFETY = (64); /* we allow length table decoding overruns */
}
}

48
BinaryObjectScanner.Models/Compression/LZX/Enums.cs
View File

@@ -1,48 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
/// <summary>
/// 3-bit block type
/// </summary>
public enum BlockType : byte
{
/// <summary>
/// Not valid
/// </summary>
INVALID_0 = 0b000,
/// <summary>
/// Verbatim block
/// </summary>
Verbatim = 0b001,
/// <summary>
/// Aligned offset block
/// </summary>
AlignedOffset = 0b010,
/// <summary>
/// Uncompressed block
/// </summary>
Uncompressed = 0b011,
/// <summary>
/// Not valid
/// </summary>
INVALID_4 = 0b100,
/// <summary>
/// Not valid
/// </summary>
INVALID_5 = 0b101,
/// <summary>
/// Not valid
/// </summary>
INVALID_6 = 0b110,
/// <summary>
/// Not valid
/// </summary>
INVALID_7 = 0b111,
}
}

102
BinaryObjectScanner.Models/Compression/LZX/Header.cs
View File

@@ -1,102 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
public class Header
{
/*
2.2 Header
2.2.1 Chunk Size
The LZXD compressor emits chunks of compressed data. A chunk represents exactly 32 KB of
uncompressed data until the last chunk in the stream, which can represent less than 32 KB. To
ensure that an exact number of input bytes represent an exact number of output bytes for each
chunk, after each 32 KB of uncompressed data is represented in the output compressed bitstream, the
output bitstream is padded with up to 15 bits of zeros to realign the bitstream on a 16-bit boundary
(even byte boundary) for the next 32 KB of data. This results in a compressed chunk of a byte-aligned
size. The compressed chunk could be smaller than 32 KB or larger than 32 KB if the data is
incompressible when the chunk is not the last one.
The LZXD engine encodes a compressed, chunk-size prefix field preceding each compressed chunk in
the compressed byte stream. The compressed, chunk-size prefix field is a byte aligned, little-endian,
16-bit field. The chunk prefix chain could be followed in the compressed stream without
decompressing any data. The next chunk prefix is at a location computed by the absolute byte offset
location of this chunk prefix plus 2 (for the size of the chunk-size prefix field) plus the current chunk
size.
2.2.2 E8 Call Translation
E8 call translation is an optional feature that can be used when the data to compress contains x86
instruction sequences. E8 translation operates as a preprocessing stage before compressing each
chunk, and the compressed stream header contains a bit that indicates whether the decoder shall
reverse the translation as a postprocessing step after decompressing each chunk.
The x86 instruction beginning with a byte value of 0xE8 is followed by a 32-bit, little-endian relative
displacement to the call target. When E8 call translation is enabled, the following preprocessing steps
are performed on the uncompressed input before compression (assuming little-endian byte ordering):
Let chunk_offset refer to the total number of uncompressed bytes preceding this chunk.
Let E8_file_size refer to the caller-specified value given to the compressor or decoded from the header
of the compressed stream during decompression.
The following example shows how E8 translation is performed for each 32-KB chunk of uncompressed
data (or less than 32 KB if last chunk to compress).
if (( chunk_offset < 0x40000000 ) && ( chunk_size > 10 ))
for ( i = 0; i < (chunk_size – 10); i++ )
if ( chunk_byte[ i ] == 0xE8 )
long current_pointer = chunk_offset + i;
long displacement = chunk_byte[ i+1 ] |
chunk_byte[ i+2 ] << 8 |
chunk_byte[ i+3 ] << 16 |
chunk_byte[ i+4 ] << 24;
long target = current_pointer + displacement;
if (( target >= 0 ) && ( target < E8_file_size+current_pointer))
if ( target >= E8_file_size )
target = displacement – E8_file_size;
endif
chunk_byte[ i+1 ] = (byte)( target );
chunk_byte[ i+2 ] = (byte)( target >> 8 );
chunk_byte[ i+3 ] = (byte)( target >> 16 );
chunk_byte[ i+4 ] = (byte)( target >> 24 );
endif
i += 4;
endif
endfor
endif
After decompression, the E8 scanning algorithm is the same. The following example shows how E8
translation reversal is performed.
long value = chunk_byte[ i+1 ] |
chunk_byte[ i+2 ] << 8 |
chunk_byte[ i+3 ] << 16 |
chunk_byte[ i+4 ] << 24;
if (( value >= -current_pointer ) && ( value < E8_file_size ))
if ( value >= 0 )
displacement = value – current_pointer;
else
displacement = value + E8_file_size;
endif
chunk_byte[ i+1 ] = (byte)( displacement );
chunk_byte[ i+2 ] = (byte)( displacement >> 8 );
chunk_byte[ i+3 ] = (byte)( displacement >> 16 );
chunk_byte[ i+4 ] = (byte)( displacement >> 24 );
endif
The first bit in the first chunk in the LZXD bitstream (following the 2-byte, chunk-size prefix described
in section 2.2.1) indicates the presence or absence of two 16-bit fields immediately following the
single bit. If the bit is set, E8 translation is enabled for all the following chunks in the stream using the
32-bit value derived from the two 16-bit fields as the E8_file_size provided to the compressor when E8
translation was enabled. Note that E8_file_size is completely independent of the length of the
uncompressed data. E8 call translation is disabled after the 32,768th chunk (after 1 gigabyte (GB) of
uncompressed data).
Field Comments Size
----------------------------------------------------------------
E8 translation 0-disabled, 1-enabled 1 bit
Translation size high word Only present if enabled 0 or 16 bits
Translation size low word Only present if enabled 0 or 16 bits
*/
}
}

59
BinaryObjectScanner.Models/Compression/LZX/UncompressedBlock.cs
View File

@@ -1,59 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
/// <summary>
/// Following the generic block header, an uncompressed block begins with 1 to 16 bits of zero padding
/// to align the bit buffer on a 16-bit boundary. At this point, the bitstream ends and a byte stream
/// begins. Following the zero padding, new 32-bit values for R0, R1, and R2 are output in little-endian
/// form, followed by the uncompressed data bytes themselves. Finally, if the uncompressed data length
/// is odd, one extra byte of zero padding is encoded to realign the following bitstream.
///
/// Then the bitstream of byte-swapped 16-bit integers resumes for the next Block Type field (if there
/// are subsequent blocks).
///
/// The decoded R0, R1, and R2 values are used as initial repeated offset values to decode the
/// subsequent compressed block if present.
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
public class UncompressedBlock
{
/// <summary>
/// Generic block header
/// </summary>
public BlockHeader Header;
/// <summary>
/// Padding to align following field on 16-bit boundary
/// </summary>
/// <remarks>Bits have a value of zero</remarks>
public ushort PaddingBits;
/// <summary>
/// Least significant to most significant byte (little-endian DWORD ([MS-DTYP]))
/// </summary>
/// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
public uint R0;
/// <summary>
/// Least significant to most significant byte (little-endian DWORD)
/// </summary>
/// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
public uint R1;
/// <summary>
/// Least significant to most significant byte (little-endian DWORD)
/// </summary>
/// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
public uint R2;
/// <summary>
/// Can use the direct memcpy function, as specified in [IEEE1003.1]
/// </summary>
/// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
public byte[] RawDataBytes;
/// <summary>
/// Only if uncompressed size is odd
/// </summary>
public byte AlignmentByte;
}
}

54
BinaryObjectScanner.Models/Compression/LZX/VerbatimBlock.cs
View File

@@ -1,54 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.LZX
{
/// <summary>
/// The fields of a verbatim block that follow the generic block header
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
public class VerbatimBlock
{
/// <summary>
/// Generic block header
/// </summary>
public BlockHeader Header;
/// <summary>
/// Pretree for first 256 elements of main tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeFirst256;
/// <summary>
/// Path lengths of first 256 elements of main tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsFirst256;
/// <summary>
/// Pretree for remainder of main tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeRemainder;
/// <summary>
/// Path lengths of remaining elements of main tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsRemainder;
/// <summary>
/// Pretree for length tree
/// </summary>
/// <remarks>20 elements, 4 bits each</remarks>
public byte[] PretreeLengthTree;
/// <summary>
/// Path lengths of elements in length tree
/// </summary>
/// <remarks>Encoded using pretree</remarks>
public int[] PathLengthsLengthTree;
// Entry Comments Size
// ---------------------------------------------------------------------------------------
// Token sequence (matches and literals) Specified in section 2.6 Variable
}
}

28
BinaryObjectScanner.Models/Compression/MSZIP/BlockHeader.cs
View File

@@ -1,28 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <summary>
/// Each MSZIP block MUST consist of a 2-byte MSZIP signature and one or more RFC 1951 blocks. The
/// 2-byte MSZIP signature MUST consist of the bytes 0x43 and 0x4B. The MSZIP signature MUST be
/// the first 2 bytes in the MSZIP block. The MSZIP signature is shown in the following packet diagram.
///
/// Each MSZIP block is the result of a single deflate compression operation, as defined in [RFC1951].
/// The compressor that performs the compression operation MUST generate one or more RFC 1951
/// blocks, as defined in [RFC1951]. The number, deflation mode, and type of RFC 1951 blocks in each
/// MSZIP block is determined by the compressor, as defined in [RFC1951]. The last RFC 1951 block in
/// each MSZIP block MUST be marked as the "end" of the stream(1), as defined by [RFC1951]
/// section 3.2.3. Decoding trees MUST be discarded after each RFC 1951 block, but the history buffer
/// MUST be maintained.Each MSZIP block MUST represent no more than 32 KB of uncompressed data.
///
/// The maximum compressed size of each MSZIP block is 32 KB + 12 bytes. This enables the MSZIP
/// block to contain 32 KB of data split between two noncompressed RFC 1951 blocks, each of which
/// has a value of BTYPE = 00.
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
public class BlockHeader
{
/// <summary>
/// 'CK'
/// </summary>
public ushort Signature;
}
}

89
BinaryObjectScanner.Models/Compression/MSZIP/Constants.cs
View File

@@ -1,89 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
public static class Constants
{
/// <summary>
/// Window size
/// </summary>
public const ushort ZIPWSIZE = 0x8000;
/// <summary>
/// Bits in base literal/length lookup table
/// </summary>
public const int ZIPLBITS = 9;
/// <summary>
/// Bits in base distance lookup table
/// </summary>
public const int ZIPDBITS = 6;
/// <summary>
/// Maximum bit length of any code
/// </summary>
public const int ZIPBMAX = 16;
/// <summary>
/// Maximum number of codes in any set
/// </summary>
public const int ZIPN_MAX = 288;
#region THOSE_ZIP_CONSTS
/// <summary>
/// Order of the bit length code lengths
/// </summary>
public static readonly byte[] BitLengthOrder = new byte[]
{
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
};
/// <summary>
/// Copy lengths for literal codes 257..285
/// </summary>
public static readonly ushort[] CopyLengths = new ushort[]
{
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51,
59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
};
/// <summary>
/// Extra bits for literal codes 257..285
/// </summary>
/// <remarks>99 == invalid</remarks>
public static readonly ushort[] LiteralExtraBits = new ushort[]
{
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
4, 5, 5, 5, 5, 0, 99, 99
};
/// <summary>
/// Copy offsets for distance codes 0..29
/// </summary>
public static readonly ushort[] CopyOffsets = new ushort[]
{
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385,
513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
};
/// <summary>
/// Extra bits for distance codes
/// </summary>
public static readonly ushort[] DistanceExtraBits = new ushort[]
{
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10,
10, 11, 11, 12, 12, 13, 13
};
/// <summary>
/// And'ing with Zipmask[n] masks the lower n bits
/// </summary>
public static readonly ushort[] BitMasks = new ushort[17]
{
0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};
#endregion
}
}

18
BinaryObjectScanner.Models/Compression/MSZIP/DeflateBlockHeader.cs
View File

@@ -1,18 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
public class DeflateBlockHeader
{
/// <summary>
/// Set if and only if this is the last block of the data set.
/// </summary>
/// <remarks>Bit 0</remarks>
public bool BFINAL { get; set; }
/// <summary>
/// Specifies how the data are compressed
/// </summary>
/// <remarks>Bits 1-2</remarks>
public CompressionType BTYPE { get; set; }
}
}

19
BinaryObjectScanner.Models/Compression/MSZIP/DynamicHuffmanCompressedBlockHeader.cs
View File

@@ -1,19 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <summary>
/// Compression with dynamic Huffman codes (BTYPE=10)
/// </summary>
/// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
public class DynamicHuffmanCompressedBlockHeader
{
/// <summary>
/// Huffman code lengths for the literal / length alphabet
/// </summary>
public int[] LiteralLengths;
/// <summary>
/// Huffman distance codes for the literal / length alphabet
/// </summary>
public int[] DistanceCodes;
}
}

25
BinaryObjectScanner.Models/Compression/MSZIP/Enums.cs
View File

@@ -1,25 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
public enum CompressionType : byte
{
/// <summary>
/// no compression
/// </summary>
NoCompression = 0b00,
/// <summary>
/// Compressed with fixed Huffman codes
/// </summary>
FixedHuffman = 0b01,
/// <summary>
/// Compressed with dynamic Huffman codes
/// </summary>
DynamicHuffman = 0b10,
/// <summary>
/// Reserved (error)
/// </summary>
Reserved = 0b11,
}
}

94
BinaryObjectScanner.Models/Compression/MSZIP/FixedHuffmanCompressedBlockHeader.cs
View File

@@ -1,94 +0,0 @@
using System;
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <summary>
/// Compression with fixed Huffman codes (BTYPE=01)
/// </summary>
/// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
/// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
public class FixedHuffmanCompressedBlockHeader
{
#region Properties
/// <summary>
/// Huffman code lengths for the literal / length alphabet
/// </summary>
public uint[] LiteralLengths
{
get
{
// If we have cached lengths, use those
if (_literalLengths != null)
return _literalLengths;
// Otherwise, build it from scratch
_literalLengths = new uint[288];
// Literal Value 0 - 143, 8 bits
for (int i = 0; i < 144; i++)
_literalLengths[i] = 8;
// Literal Value 144 - 255, 9 bits
for (int i = 144; i < 256; i++)
_literalLengths[i] = 9;
// Literal Value 256 - 279, 7 bits
for (int i = 256; i < 280; i++)
_literalLengths[i] = 7;
// Literal Value 280 - 287, 8 bits
for (int i = 280; i < 288; i++)
_literalLengths[i] = 8;
return _literalLengths;
}
set
{
throw new FieldAccessException();
}
}
/// <summary>
/// Huffman distance codes for the literal / length alphabet
/// </summary>
public uint[] DistanceCodes
{
get
{
// If we have cached distances, use those
if (_distanceCodes != null)
return _distanceCodes;
// Otherwise, build it from scratch
_distanceCodes = new uint[30];
// Fixed length, 5 bits
for (int i = 0; i < 30; i++)
_distanceCodes[i] = 5;
return _distanceCodes;
}
set
{
throw new FieldAccessException();
}
}
#endregion
#region Instance Variables
/// <summary>
/// Huffman code lengths for the literal / length alphabet
/// </summary>
private uint[] _literalLengths = null;
/// <summary>
/// Huffman distance codes for the literal / length alphabet
/// </summary>
private uint[] _distanceCodes = null;
#endregion
}
}

21
BinaryObjectScanner.Models/Compression/MSZIP/NonCompressedBlockHeader.cs
View File

@@ -1,21 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.MSZIP
{
/// <summary>
/// Non-compressed blocks (BTYPE=00)
/// </summary>
/// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
public class NonCompressedBlockHeader
{
/// <summary>
/// The number of data bytes in the block
/// </summary>
/// <remarks>Bytes 0-1</remarks>
public ushort LEN;
/// <summary>
/// The one's complement of LEN
/// </summary>
/// <remarks>Bytes 2-3</remarks>
public ushort NLEN;
}
}

45
BinaryObjectScanner.Models/Compression/Quantum/Constants.cs
View File

@@ -1,45 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.Quantum
{
public static class Constants
{
/// <summary>
/// Mask for Quantum Compression Level
/// </summary>
public const ushort MASK_QUANTUM_LEVEL = 0x00F0;
/// <summary>
/// Lowest Quantum Level (1)
/// </summary>
public const ushort QUANTUM_LEVEL_LO = 0x0010;
/// <summary>
/// Highest Quantum Level (7)
/// </summary>
public const ushort QUANTUM_LEVEL_HI = 0x0070;
/// <summary>
/// Amount to shift over to get int
/// </summary>
public const ushort SHIFT_QUANTUM_LEVEL = 4;
/// <summary>
/// Mask for Quantum Compression Memory
/// </summary>
public const ushort MASK_QUANTUM_MEM = 0x1F00;
/// <summary>
/// Lowest Quantum Memory (10)
/// </summary>
public const ushort QUANTUM_MEM_LO = 0x0A00;
/// <summary>
/// Highest Quantum Memory (21)
/// </summary>
public const ushort QUANTUM_MEM_HI = 0x1500;
/// <summary>
/// Amount to shift over to get int
/// </summary>
public const ushort SHIFT_QUANTUM_MEM = 8;
}
}

45
BinaryObjectScanner.Models/Compression/Quantum/Enums.cs
View File

@@ -1,45 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.Quantum
{
public enum SelectorModel
{
/// <summary>
/// Literal model, 64 entries, start at symbol 0
/// </summary>
SELECTOR_0 = 0,
/// <summary>
/// Literal model, 64 entries, start at symbol 64
/// </summary>
SELECTOR_1 = 1,
/// <summary>
/// Literal model, 64 entries, start at symbol 128
/// </summary>
SELECTOR_2 = 2,
/// <summary>
/// Literal model, 64 entries, start at symbol 192
/// </summary>
SELECTOR_3 = 3,
/// <summary>
/// LZ model, 3 character matches, max 24 entries, start at symbol 0
/// </summary>
SELECTOR_4 = 4,
/// <summary>
/// LZ model, 4 character matches, max 36 entries, start at symbol 0
/// </summary>
SELECTOR_5 = 5,
/// <summary>
/// LZ model, 5+ character matches, max 42 entries, start at symbol 0
/// </summary>
SELECTOR_6_POSITION = 6,
/// <summary>
/// LZ model, 5+ character matches, 27 entries, start at symbol 0
/// </summary>
SELECTOR_6_LENGTH = 7,
}
}

15
BinaryObjectScanner.Models/Compression/Quantum/Model.cs
View File

@@ -1,15 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.Quantum
{
/// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
/// <see href="http://www.russotto.net/quantumcomp.html"/>
public sealed class Model
{
public int TimeToReorder;
public int Entries;
public ModelSymbol[] Symbols;
public ushort[] LookupTable = new ushort[256];
}
}

11
BinaryObjectScanner.Models/Compression/Quantum/ModelSymbol.cs
View File

@@ -1,11 +0,0 @@
namespace BinaryObjectScanner.Models.Compression.Quantum
{
/// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
/// <see href="http://www.russotto.net/quantumcomp.html"/>
public sealed class ModelSymbol
{
public ushort Symbol;
public ushort CumulativeFrequency;
}
}

31
BinaryObjectScanner.Models/DVD/AudioSubPictureAttributesTable.cs
View File

@@ -1,31 +0,0 @@
namespace BinaryObjectScanner.Models.DVD
{
/// <see href="https://dvd.sourceforge.net/dvdinfo/ifo.html"/>
public sealed class AudioSubPictureAttributesTable
{
/// <summary>
/// Number of title sets
/// </summary>
public ushort NumberOfTitleSets;
/// <summary>
/// Reserved
/// </summary>
public byte[] Reserved;
/// <summary>
/// End address (last byte of last VTS_ATRT)
/// </summary>
public uint EndAddress;
/// <summary>
/// Offset to VTS_ATRT n
/// </summary>
public uint[] Offsets;
/// <summary>
/// Entries
/// </summary>
public AudioSubPictureAttributesTableEntry[] Entries;
}
}

23
BinaryObjectScanner.Models/DVD/AudioSubPictureAttributesTableEntry.cs
View File

@@ -1,23 +0,0 @@
namespace BinaryObjectScanner.Models.DVD
{
/// <see href="https://dvd.sourceforge.net/dvdinfo/ifo.html"/>
public sealed class AudioSubPictureAttributesTableEntry
{
/// <summary>
/// End address (EA)
/// </summary>
public uint EndAddress;
/// <summary>
/// VTS_CAT (copy of offset 022-025 of the VTS IFO file)
/// 0=unspecified, 1=Karaoke
/// </summary>
public uint Category;
/// <summary>
/// Copy of VTS attributes (offset 100 and on from the VTS IFO
/// file, usually 0x300 bytes long)
/// </summary>
public byte[] AttributesCopy;
}
}

26
BinaryObjectScanner.Models/DVD/CellAddressTable.cs
View File

@@ -1,26 +0,0 @@
namespace BinaryObjectScanner.Models.DVD
{
/// <see href="https://dvd.sourceforge.net/dvdinfo/ifo.html"/>
public sealed class CellAddressTable
{
/// <summary>
/// Number of VOB IDs
/// </summary>
public ushort NumberOfVOBIDs;
/// <summary>
/// Reserved
/// </summary>
public byte[] Reserved;
/// <summary>
/// End address (last byte of last entry)
/// </summary>
public uint EndAddress;
/// <summary>
/// 12-byte entries
/// </summary>
public CellAddressTableEntry[] Entries;
}
}

Some files were not shown because too many files have changed in this diff Show More