mirror of
https://github.com/SabreTools/SabreTools.Serialization.git
synced 2026-04-05 22:01:33 +00:00
362 lines
14 KiB
C#
362 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using SabreTools.Data.Extensions;
|
|
using SabreTools.Data.Models.CFB;
|
|
using SabreTools.IO.Extensions;
|
|
using SabreTools.Numerics.Extensions;
|
|
using static SabreTools.Data.Models.CFB.Constants;
|
|
|
|
#pragma warning disable IDE0017 // Simplify object initialization
|
|
namespace SabreTools.Serialization.Readers
|
|
{
|
|
public class CFB : BaseBinaryReader<Binary>
|
|
{
|
|
/// <inheritdoc/>
|
|
public override Binary? Deserialize(Stream? data)
|
|
{
|
|
// If the data is invalid
|
|
if (data is null || !data.CanRead)
|
|
return null;
|
|
|
|
try
|
|
{
|
|
// Cache the current offset
|
|
long initialOffset = data.Position;
|
|
|
|
// Create a new binary to fill
|
|
var binary = new Binary();
|
|
|
|
#region Header
|
|
|
|
// Try to parse the file header
|
|
var fileHeader = ParseFileHeader(data);
|
|
if (fileHeader?.Signature != SignatureUInt64)
|
|
return null;
|
|
if (fileHeader.ByteOrder != 0xFFFE)
|
|
return null;
|
|
if (fileHeader.MajorVersion == 3 && fileHeader.SectorShift != 0x0009)
|
|
return null;
|
|
else if (fileHeader.MajorVersion == 4 && fileHeader.SectorShift != 0x000C)
|
|
return null;
|
|
if (fileHeader.MajorVersion == 3 && fileHeader.NumberOfDirectorySectors != 0)
|
|
return null;
|
|
if (fileHeader.MiniStreamCutoffSize != 0x00001000)
|
|
return null;
|
|
|
|
// Set the file header
|
|
binary.Header = fileHeader;
|
|
|
|
#endregion
|
|
|
|
#region DIFAT Sector Numbers
|
|
|
|
// Create a DIFAT sector table
|
|
var difatSectors = new List<SectorNumber>();
|
|
|
|
// Add the sectors from the header
|
|
if (fileHeader.DIFAT is not null)
|
|
difatSectors.AddRange(fileHeader.DIFAT);
|
|
|
|
// Loop through and add the DIFAT sectors
|
|
var currentSector = (SectorNumber?)fileHeader.FirstDIFATSectorLocation;
|
|
for (int i = 0; i < fileHeader.NumberOfDIFATSectors; i++)
|
|
{
|
|
// If we have an unreadable sector
|
|
if (currentSector > SectorNumber.MAXREGSECT)
|
|
break;
|
|
|
|
// Get the new next sector information
|
|
long sectorOffset = initialOffset
|
|
+ (long)((long)(currentSector + 1) * Math.Pow(2, fileHeader.SectorShift));
|
|
if (sectorOffset < initialOffset || sectorOffset >= data.Length)
|
|
return null;
|
|
|
|
// Seek to the next sector
|
|
data.SeekIfPossible(sectorOffset, SeekOrigin.Begin);
|
|
|
|
// Try to parse the sectors
|
|
var sectorNumbers = ParseSectorNumbers(data, fileHeader.SectorShift);
|
|
if (sectorNumbers is null)
|
|
return null;
|
|
|
|
// Add all but the last sector number that was parsed
|
|
for (int j = 0; j < sectorNumbers.Length - 1; j++)
|
|
{
|
|
difatSectors.Add(sectorNumbers[j]);
|
|
}
|
|
|
|
// Get the next sector from the final sector number
|
|
#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
|
|
currentSector = sectorNumbers[^1];
|
|
#else
|
|
currentSector = sectorNumbers[sectorNumbers.Length - 1];
|
|
#endif
|
|
}
|
|
|
|
// Assign the DIFAT sectors table
|
|
binary.DIFATSectorNumbers = [.. difatSectors];
|
|
|
|
#endregion
|
|
|
|
#region FAT Sector Numbers
|
|
|
|
// Create a FAT sector table
|
|
var fatSectors = new List<SectorNumber>();
|
|
|
|
// Loop through and add the FAT sectors
|
|
for (int i = 0; i < fileHeader.NumberOfFATSectors; i++)
|
|
{
|
|
// Get the next sector from the DIFAT
|
|
currentSector = binary.DIFATSectorNumbers[i];
|
|
|
|
// If we have an unreadable sector
|
|
if (currentSector > SectorNumber.MAXREGSECT)
|
|
break;
|
|
|
|
// Get the new next sector information
|
|
long sectorOffset = initialOffset
|
|
+ (long)((long)(currentSector + 1) * Math.Pow(2, fileHeader.SectorShift));
|
|
if (sectorOffset < initialOffset || sectorOffset >= data.Length)
|
|
return null;
|
|
|
|
// Seek to the next sector
|
|
data.SeekIfPossible(sectorOffset, SeekOrigin.Begin);
|
|
|
|
// Try to parse the sectors
|
|
var sectorNumbers = ParseSectorNumbers(data, fileHeader.SectorShift);
|
|
if (sectorNumbers is null)
|
|
return null;
|
|
|
|
// Add the sector shifts
|
|
fatSectors.AddRange(sectorNumbers);
|
|
}
|
|
|
|
// Assign the FAT sectors table
|
|
binary.FATSectorNumbers = [.. fatSectors];
|
|
|
|
#endregion
|
|
|
|
#region Mini FAT Sector Numbers
|
|
|
|
// Create a mini FAT sector table
|
|
var miniFatSectors = new List<SectorNumber>();
|
|
|
|
// Loop through and add the mini FAT sectors
|
|
currentSector = (SectorNumber)fileHeader.FirstMiniFATSectorLocation;
|
|
for (int i = 0; i < fileHeader.NumberOfMiniFATSectors; i++)
|
|
{
|
|
// If we have an unreadable sector
|
|
if (currentSector > SectorNumber.MAXREGSECT)
|
|
break;
|
|
|
|
// Get the new next sector information
|
|
long sectorOffset = initialOffset
|
|
+ (long)((long)(currentSector + 1) * Math.Pow(2, fileHeader.SectorShift));
|
|
if (sectorOffset < initialOffset || sectorOffset >= data.Length)
|
|
return null;
|
|
|
|
// Seek to the next sector
|
|
data.SeekIfPossible(sectorOffset, SeekOrigin.Begin);
|
|
|
|
// Try to parse the sectors
|
|
var sectorNumbers = ParseSectorNumbers(data, fileHeader.SectorShift);
|
|
if (sectorNumbers is null)
|
|
return null;
|
|
|
|
// Add the sector shifts
|
|
miniFatSectors.AddRange(sectorNumbers);
|
|
|
|
// Get the next sector from the FAT
|
|
currentSector = binary.FATSectorNumbers[(int)currentSector];
|
|
}
|
|
|
|
// Assign the mini FAT sectors table
|
|
binary.MiniFATSectorNumbers = [.. miniFatSectors];
|
|
|
|
#endregion
|
|
|
|
#region Directory Entries
|
|
|
|
// Create a directory sector table
|
|
var directorySectors = new List<DirectoryEntry>();
|
|
|
|
// Get the number of directory sectors
|
|
uint directorySectorCount = 0;
|
|
switch (fileHeader.MajorVersion)
|
|
{
|
|
case 3:
|
|
directorySectorCount = int.MaxValue;
|
|
break;
|
|
case 4:
|
|
directorySectorCount = fileHeader.NumberOfDirectorySectors;
|
|
break;
|
|
default:
|
|
// TODO: Log invalid values
|
|
break;
|
|
}
|
|
|
|
// Loop through and add the directory sectors
|
|
currentSector = (SectorNumber)fileHeader.FirstDirectorySectorLocation;
|
|
for (int i = 0; i < directorySectorCount; i++)
|
|
{
|
|
// If we have an end of chain
|
|
if (currentSector == SectorNumber.ENDOFCHAIN)
|
|
break;
|
|
|
|
// If we have an unusable sector for a version 3 file
|
|
if (directorySectorCount == int.MaxValue && currentSector > SectorNumber.MAXREGSECT)
|
|
break;
|
|
|
|
// Get the new next sector information
|
|
long sectorOffset = initialOffset
|
|
+ (long)((long)(currentSector + 1) * Math.Pow(2, fileHeader.SectorShift));
|
|
if (sectorOffset < initialOffset || sectorOffset >= data.Length)
|
|
return null;
|
|
|
|
// Seek to the next sector
|
|
data.SeekIfPossible(sectorOffset, SeekOrigin.Begin);
|
|
|
|
// Try to parse the sectors
|
|
var directoryEntries = ParseDirectoryEntries(data, fileHeader.SectorShift, fileHeader.MajorVersion);
|
|
if (directoryEntries is null)
|
|
return null;
|
|
|
|
// Add the sector shifts
|
|
directorySectors.AddRange(directoryEntries);
|
|
|
|
// Get the next sector from the FAT
|
|
currentSector = binary.FATSectorNumbers[(int)currentSector];
|
|
}
|
|
|
|
// Assign the Directory sectors table
|
|
binary.DirectoryEntries = [.. directorySectors];
|
|
|
|
#endregion
|
|
|
|
return binary;
|
|
}
|
|
catch
|
|
{
|
|
// Ignore the actual error
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse a Stream into a DirectoryEntry
|
|
/// </summary>
|
|
/// <param name="data">Stream to parse</param>
|
|
/// <returns>Filled DirectoryEntry on success, null on error</returns>
|
|
public static DirectoryEntry ParseDirectoryEntry(Stream data)
|
|
{
|
|
var obj = new DirectoryEntry();
|
|
|
|
byte[] name = data.ReadBytes(64);
|
|
obj.Name = Encoding.Unicode.GetString(name).DecodeStreamName()?.TrimEnd('\0') ?? string.Empty;
|
|
obj.NameLength = data.ReadUInt16LittleEndian();
|
|
obj.ObjectType = (ObjectType)data.ReadByteValue();
|
|
obj.ColorFlag = (ColorFlag)data.ReadByteValue();
|
|
obj.LeftSiblingID = (StreamID)data.ReadUInt32LittleEndian();
|
|
obj.RightSiblingID = (StreamID)data.ReadUInt32LittleEndian();
|
|
obj.ChildID = (StreamID)data.ReadUInt32LittleEndian();
|
|
obj.CLSID = data.ReadGuid();
|
|
obj.StateBits = data.ReadUInt32LittleEndian();
|
|
obj.CreationTime = data.ReadUInt64LittleEndian();
|
|
obj.ModifiedTime = data.ReadUInt64LittleEndian();
|
|
obj.StartingSectorLocation = data.ReadUInt32LittleEndian();
|
|
obj.StreamSize = data.ReadUInt64LittleEndian();
|
|
|
|
return obj;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse a Stream into a FileHeader
|
|
/// </summary>
|
|
/// <param name="data">Stream to parse</param>
|
|
/// <returns>Filled FileHeader on success, null on error</returns>
|
|
public static FileHeader ParseFileHeader(Stream data)
|
|
{
|
|
var obj = new FileHeader();
|
|
|
|
obj.Signature = data.ReadUInt64LittleEndian();
|
|
obj.CLSID = data.ReadGuid();
|
|
obj.MinorVersion = data.ReadUInt16LittleEndian();
|
|
obj.MajorVersion = data.ReadUInt16LittleEndian();
|
|
obj.ByteOrder = data.ReadUInt16LittleEndian();
|
|
obj.SectorShift = data.ReadUInt16LittleEndian();
|
|
obj.MiniSectorShift = data.ReadUInt16LittleEndian();
|
|
obj.Reserved = data.ReadBytes(6);
|
|
obj.NumberOfDirectorySectors = data.ReadUInt32LittleEndian();
|
|
obj.NumberOfFATSectors = data.ReadUInt32LittleEndian();
|
|
obj.FirstDirectorySectorLocation = data.ReadUInt32LittleEndian();
|
|
obj.TransactionSignatureNumber = data.ReadUInt32LittleEndian();
|
|
obj.MiniStreamCutoffSize = data.ReadUInt32LittleEndian();
|
|
obj.FirstMiniFATSectorLocation = data.ReadUInt32LittleEndian();
|
|
obj.NumberOfMiniFATSectors = data.ReadUInt32LittleEndian();
|
|
obj.FirstDIFATSectorLocation = data.ReadUInt32LittleEndian();
|
|
obj.NumberOfDIFATSectors = data.ReadUInt32LittleEndian();
|
|
obj.DIFAT = new SectorNumber[109];
|
|
for (int i = 0; i < 109; i++)
|
|
{
|
|
obj.DIFAT[i] = (SectorNumber)data.ReadUInt32LittleEndian();
|
|
}
|
|
|
|
// Skip rest of sector for version 4
|
|
if (obj.MajorVersion == 4)
|
|
_ = data.ReadBytes(3584);
|
|
|
|
return obj;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse a Stream into a sector full of sector numbers
|
|
/// </summary>
|
|
/// <param name="data">Stream to parse</param>
|
|
/// <param name="sectorShift">Sector shift from the header</param>
|
|
/// <returns>Filled sector full of sector numbers on success, null on error</returns>
|
|
private static SectorNumber[] ParseSectorNumbers(Stream data, ushort sectorShift)
|
|
{
|
|
int sectorCount = (int)(Math.Pow(2, sectorShift) / sizeof(uint));
|
|
var sectorNumbers = new SectorNumber[sectorCount];
|
|
|
|
for (int i = 0; i < sectorNumbers.Length; i++)
|
|
{
|
|
sectorNumbers[i] = (SectorNumber)data.ReadUInt32LittleEndian();
|
|
}
|
|
|
|
return sectorNumbers;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse a Stream into a sector full of directory entries
|
|
/// </summary>
|
|
/// <param name="data">Stream to parse</param>
|
|
/// <param name="sectorShift">Sector shift from the header</param>
|
|
/// <param name="majorVersion">Major version from the header</param>
|
|
/// <returns>Filled sector full of directory entries on success, null on error</returns>
|
|
private static DirectoryEntry[]? ParseDirectoryEntries(Stream data, ushort sectorShift, ushort majorVersion)
|
|
{
|
|
// <see href="https://winprotocoldoc.z19.web.core.windows.net/MS-CFB/%5bMS-CFB%5d.pdf"/>
|
|
int directoryEntrySize = 128;
|
|
|
|
int dirsPerSector = (int)(Math.Pow(2, sectorShift) / directoryEntrySize);
|
|
var directoryEntries = new DirectoryEntry[dirsPerSector];
|
|
|
|
for (int i = 0; i < directoryEntries.Length; i++)
|
|
{
|
|
var directoryEntry = ParseDirectoryEntry(data);
|
|
|
|
// Handle version 3 entries
|
|
if (majorVersion == 3)
|
|
directoryEntry.StreamSize &= 0x00000000FFFFFFFF;
|
|
|
|
directoryEntries[i] = directoryEntry;
|
|
}
|
|
|
|
return directoryEntries;
|
|
}
|
|
}
|
|
}
|