public XeXHeader(MemoryStream file)
{
MyBinaryReader reader;
try
{
reader = new MyBinaryReader(file, EndianType.BigEndian);
reader.BaseStream.Seek(0L, SeekOrigin.Begin);
if (Encoding.ASCII.GetString(reader.ReadBytes(4)) == "XEX2")
{
reader.BaseStream.Seek(20L, SeekOrigin.Begin);
uint headerCount = reader.ReadUInt32();
byte[] infoArray = new byte[] { 0, 4, 0, 6 };
for (int i = 0; i < headerCount; i++)
{
byte[] headerIdArray = reader.ReadBytes(4);
uint headerId = BitConverter.ToUInt32(headerIdArray, 0);
if (headerId == BitConverter.ToUInt32(infoArray, 0))
{
uint dataAddress = reader.ReadUInt32();
reader.BaseStream.Seek((long)dataAddress, SeekOrigin.Begin);
this.mediaId = reader.ReadBytes(4);
this.version = reader.ReadUInt32();
this.baseVersion = reader.ReadUInt32();
this.titleId = reader.ReadBytes(4);
this.platform = reader.ReadByte();
this.executableType = reader.ReadByte();
this.discNumber = reader.ReadByte();
this.discCount = reader.ReadByte();
break;
}
else
{
reader.ReadUInt32();
}
}
}
else
{
throw new Exception("Extracted file is not XEX file");
}
}
catch (Exception ex)
{
throw ex;
}
reader.Close();
}
/// <summary>
/// Search for default.xex
/// </summary>
/// <returns>true if found; false if not found</returns>
private bool SearchForDefaultXeX()
{
try
{
this.iso.Reader.BaseStream.Seek((long)(((long)this.iso.IsoInfo.RootDirSector * (long)this.iso.IsoInfo.SectorSize) + (long)this.iso.IsoInfo.RootOffset), System.IO.SeekOrigin.Begin);
byte[] rootDirBuffer = this.iso.Reader.ReadBytes((int)this.iso.IsoInfo.RootDirSize);
MemoryStream ms = new MemoryStream(rootDirBuffer);
MyBinaryReader reader = new MyBinaryReader(ms);
while (reader.BaseStream.Position < this.iso.IsoInfo.RootDirSize)
{
ushort offsetLeftSubTreeTmp = reader.ReadUInt16();
ushort offsetRightSubTreeTmp = reader.ReadUInt16();
if (offsetLeftSubTreeTmp != 0xffff && offsetRightSubTreeTmp != 0xffff)
{
uint startingSectorOfFileTmp = reader.ReadUInt32();
uint fileSizeTmp = reader.ReadUInt32();
uint fileAttribute = (uint)reader.ReadByte();
byte fileNameLengthTmp = reader.ReadByte();
string fileNameTmp = Encoding.ASCII.GetString(rootDirBuffer, (int)reader.BaseStream.Position, fileNameLengthTmp);
reader.BaseStream.Seek((long)fileNameLengthTmp, SeekOrigin.Current);
long num1 = reader.BaseStream.Position % 4L;
if ((reader.BaseStream.Position % 4L) != 0L)
{
reader.BaseStream.Seek(4L - (reader.BaseStream.Position % 4L), SeekOrigin.Current);
}
if (fileNameTmp.ToLower() == this.fileName.ToLower())
{
this.offsetLeftSubTree = offsetLeftSubTreeTmp;
this.offsetRightSubTree = offsetRightSubTreeTmp;
this.startingSectorOfFile = startingSectorOfFileTmp;
this.fileSize = fileSizeTmp;
this.fileNameLength = fileNameLengthTmp;
//this.iso.Reader.Read(this.file, (int)(this.iso.IsoInfo.RootOffset + (this.startingSectorOfFile * this.iso.IsoInfo.SectorSize)), (int)this.fileSize);
this.iso.Reader.BaseStream.Seek((long)((long)this.iso.IsoInfo.RootOffset + ((long)this.startingSectorOfFile * (long)this.iso.IsoInfo.SectorSize)), SeekOrigin.Begin);
this.file = this.iso.Reader.ReadBytes((int)this.fileSize);
return(true);
}
}
}
}
catch (Exception ex)
{
throw new Exception("Error browsing ISO for default.xex", ex);
}
return(false);
}
private long SearchForDefaultXeX()
{
try
{
this.iso.Reader.BaseStream.Seek((long)((long)((long)this.iso.IsoInfo.RootDirSector * (long)this.iso.IsoInfo.SectorSize) + (long)this.iso.IsoInfo.RootOffset), SeekOrigin.Begin);
byte[] buffer = this.iso.Reader.ReadBytes((int)this.iso.IsoInfo.RootDirSize);
MemoryStream s = new MemoryStream(buffer);
MyBinaryReader reader = new MyBinaryReader(s);
while (reader.BaseStream.Position < this.iso.IsoInfo.RootDirSize)
{
ushort num = reader.ReadUInt16();
ushort num2 = reader.ReadUInt16();
if ((num != 0xffff) && (num2 != 0xffff))
{
uint num3 = reader.ReadUInt32();
uint num4 = reader.ReadUInt32();
uint num5 = reader.ReadByte();
byte count = reader.ReadByte();
string str = Encoding.ASCII.GetString(buffer, (int)reader.BaseStream.Position, count);
reader.BaseStream.Seek((long)count, SeekOrigin.Current);
long num7 = reader.BaseStream.Position % 4L;
if ((reader.BaseStream.Position % 4L) != 0L)
{
reader.BaseStream.Seek(4L - (reader.BaseStream.Position % 4L), SeekOrigin.Current);
}
if ((str.ToLower() == this.fileName.ToLower()) || (str.ToLower() == this.fileName2.ToLower()))
{
this.offsetLeftSubTree = num;
this.offsetRightSubTree = num2;
this.startingSectorOfFile = num3;
this.fileSize = num4;
this.fileNameLength = count;
this.iso.Reader.BaseStream.Seek(((long)this.iso.IsoInfo.RootOffset + (long)((long)this.startingSectorOfFile * (long)this.iso.IsoInfo.SectorSize)), SeekOrigin.Begin);
return(iso.Reader.BaseStream.Position);
}
}
}
}
catch (Exception exception)
{
throw new Exception("Error browsing ISO for default.xex/xeb", exception);
}
return(-1);
}
public VTSM_PGCI_LU_MENU(byte[] array, int numberOfMenu)
{
MemoryStream s = new MemoryStream(array);
MyBinaryReader reader = new MyBinaryReader(s);
reader.Skip(8 + (numberOfMenu * 8));
this.isGameMenu = reader.ReadByte() == 0;
reader.Skip(3);
this.startByteVTSM_PGCI = reader.ReadInt32B();
reader.BaseStream.Seek((long)(this.startByteVTSM_PGCI + 0xe8), SeekOrigin.Begin);
short num = reader.ReadInt16B();
reader.BaseStream.Seek((long)(this.startByteVTSM_PGCI + num), SeekOrigin.Begin);
reader.Skip(8);
this.sector = reader.ReadInt32B();
}
public VTSM_PGCI_LU_MENU(byte[] array, int numberOfMenu)
{
MemoryStream ms = new MemoryStream(array);
MyBinaryReader br = new MyBinaryReader(ms);
br.Skip(8 + (numberOfMenu * 8));
//byte a = br.ReadByte();
isGameMenu = br.ReadByte() == (byte)0;
br.Skip(3);
startByteVTSM_PGCI = br.ReadInt32B();
br.BaseStream.Seek(startByteVTSM_PGCI + 0xE8, SeekOrigin.Begin);
short offsetCellPlaybackInformation = br.ReadInt16B();
br.BaseStream.Seek(startByteVTSM_PGCI + offsetCellPlaybackInformation, SeekOrigin.Begin);
br.Skip(8);
sector = br.ReadInt32B();
}
public XeXHeader(MyBinaryReader reader)
{
long position = reader.BaseStream.Position;
try
{
byte[] b = reader.ReadBytes(4);
if (Encoding.ASCII.GetString(b) == "XEX2")
{
reader.BaseStream.Seek(position + 20L, SeekOrigin.Begin);
uint num = reader.ReadUInt32();
UInt32 einfo = BitConverter.ToUInt32(executioninfo, 0);
UInt32 tstamp = BitConverter.ToUInt32(basefiletimestamp, 0);
for (int i = 0; i < num; i++)
{
UInt32 val = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
uint pos = reader.ReadUInt32();
long savepos = reader.BaseStream.Position;
if (val == einfo)
{
reader.BaseStream.Seek((long)position + pos, SeekOrigin.Begin);
this.short_mediaId = reader.ReadBytes(4);
this.version = reader.ReadUInt32();
this.baseVersion = reader.ReadUInt32();
this.titleId = reader.ReadBytes(4);
this.platform = reader.ReadByte();
this.executableType = reader.ReadByte();
this.discNumber = reader.ReadByte();
this.discCount = reader.ReadByte();
reader.BaseStream.Seek(savepos, SeekOrigin.Begin);
}
else if (val == tstamp)
{
reader.BaseStream.Seek((long)position + pos + 4, SeekOrigin.Begin);
this.date =
new DateTime(1970, 1, 1, 0, 0, 0).Add(
TimeSpan.FromTicks((long)reader.ReadUInt32() * TimeSpan.TicksPerSecond));
reader.BaseStream.Seek(savepos, SeekOrigin.Begin);
}
}
//Read cert
reader.BaseStream.Seek((long)position + 0x10, SeekOrigin.Begin);
uint offset = reader.ReadUInt32();
reader.BaseStream.Seek((long)position + (long)offset + 0x140, SeekOrigin.Begin);
mediaid = reader.ReadBytes(16);
reader.BaseStream.Seek((long)position + (long)offset + 0x178, SeekOrigin.Begin);
regioncode = reader.ReadUInt32();
}
else if (Encoding.ASCII.GetString(b) == "XBEH")
{
reader.EndianType = EndianType.LittleEndian;
reader.BaseStream.Seek(position + 0x110, SeekOrigin.Begin);
uint pos = reader.ReadUInt32();
this.date = new DateTime(1970, 1, 1, 0, 0, 0).Add(TimeSpan.FromTicks((long)reader.ReadUInt32() * TimeSpan.TicksPerSecond));
reader.BaseStream.Seek(position + pos + 0x8, SeekOrigin.Begin);
this.titleId = new byte[4];
this.titleId[3] = reader.ReadByte();
this.titleId[2] = reader.ReadByte();
this.titleId[1] = reader.ReadByte();
this.titleId[0] = reader.ReadByte();
byte[] b2 = reader.ReadBytes(0x40);
this.title = Encoding.Unicode.GetString(b2).Replace("\0", string.Empty).Trim();
reader.BaseStream.Seek(position + pos + 0xA8, SeekOrigin.Begin);
this.discNumber = this.discCount = (byte)(reader.ReadUInt32() + 1);
this.version = reader.ReadUInt32();
}
else
{
throw new Exception("Not XEX/XEB file");
}
}
catch (Exception exception)
{
if (reader != null)
{
reader.BaseStream.Seek(position, SeekOrigin.Begin);
}
throw exception;
}
reader.BaseStream.Seek(position, SeekOrigin.Begin);
}
private object?LoadObjectV1(int dataOffset)
{
Debug.Assert(System.Threading.Monitor.IsEntered(reader));
reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
int typeIndex = reader.Read7BitEncodedInt();
if (typeIndex == -1)
{
return(null);
}
string typeName = FindType(typeIndex);
int comma = typeName.IndexOf(',');
if (comma > 0)
{
// strip assembly name
typeName = typeName.Substring(0, comma);
}
switch (typeName)
{
case "System.String":
return(reader.ReadString());
case "System.Byte":
return(reader.ReadByte());
case "System.SByte":
return(reader.ReadSByte());
case "System.Int16":
return(reader.ReadInt16());
case "System.UInt16":
return(reader.ReadUInt16());
case "System.Int32":
return(reader.ReadInt32());
case "System.UInt32":
return(reader.ReadUInt32());
case "System.Int64":
return(reader.ReadInt64());
case "System.UInt64":
return(reader.ReadUInt64());
case "System.Single":
return(reader.ReadSingle());
case "System.Double":
return(reader.ReadDouble());
case "System.DateTime":
// Ideally we should use DateTime's ToBinary & FromBinary,
// but we can't for compatibility reasons.
return(new DateTime(reader.ReadInt64()));
case "System.TimeSpan":
return(new TimeSpan(reader.ReadInt64()));
case "System.Decimal":
int[] bits = new int[4];
for (int i = 0; i < bits.Length; i++)
{
bits[i] = reader.ReadInt32();
}
return(new decimal(bits));
default:
return(new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position));
}
}
public ResourcesFile(Stream stream, bool leaveOpen = true)
{
fileStartPosition = stream.Position;
reader = new MyBinaryReader(stream, leaveOpen);
const string ResourcesHeaderCorrupted = "Resources header corrupted.";
// Read ResourceManager header
// Check for magic number
int magicNum = reader.ReadInt32();
if (magicNum != MagicNumber)
{
throw new BadImageFormatException("Not a .resources file - invalid magic number");
}
// Assuming this is ResourceManager header V1 or greater, hopefully
// after the version number there is a number of bytes to skip
// to bypass the rest of the ResMgr header. For V2 or greater, we
// use this to skip to the end of the header
int resMgrHeaderVersion = reader.ReadInt32();
int numBytesToSkip = reader.ReadInt32();
if (numBytesToSkip < 0 || resMgrHeaderVersion < 0)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
if (resMgrHeaderVersion > 1)
{
reader.BaseStream.Seek(numBytesToSkip, SeekOrigin.Current);
}
else
{
// We don't care about numBytesToSkip; read the rest of the header
// readerType:
reader.ReadString();
// resourceSetType:
reader.ReadString();
}
// Read RuntimeResourceSet header
// Do file version check
version = reader.ReadInt32();
if (version != ResourceSetVersion && version != 1)
{
throw new BadImageFormatException($"Unsupported resource set version: {version}");
}
numResources = reader.ReadInt32();
if (numResources < 0)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
// Read type positions into type positions array.
// But delay initialize the type table.
int numTypes = reader.ReadInt32();
if (numTypes < 0)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
typeTable = new string[numTypes];
for (int i = 0; i < numTypes; i++)
{
typeTable[i] = reader.ReadString();
}
// Prepare to read in the array of name hashes
// Note that the name hashes array is aligned to 8 bytes so
// we can use pointers into it on 64 bit machines. (4 bytes
// may be sufficient, but let's plan for the future)
// Skip over alignment stuff. All public .resources files
// should be aligned No need to verify the byte values.
long pos = reader.BaseStream.Position - fileStartPosition;
int alignBytes = unchecked ((int)pos) & 7;
if (alignBytes != 0)
{
for (int i = 0; i < 8 - alignBytes; i++)
{
reader.ReadByte();
}
}
// Skip over the array of name hashes
try
{
reader.Seek(checked (4 * numResources), SeekOrigin.Current);
}
catch (OverflowException)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
// Read in the array of relative positions for all the names.
namePositions = new int[numResources];
for (int i = 0; i < numResources; i++)
{
int namePosition = reader.ReadInt32();
if (namePosition < 0)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
namePositions[i] = namePosition;
}
// Read location of data section.
int dataSectionOffset = reader.ReadInt32();
if (dataSectionOffset < 0)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
// Store current location as start of name section
nameSectionPosition = reader.BaseStream.Position;
dataSectionPosition = fileStartPosition + dataSectionOffset;
// _nameSectionOffset should be <= _dataSectionOffset; if not, it's corrupt
if (dataSectionPosition < nameSectionPosition)
{
throw new BadImageFormatException(ResourcesHeaderCorrupted);
}
}
public List <IConstant> Parse(MyBinaryReader reader)
{
// заполняем первый индекс заглушкой, т.к. здесь нумерация с единицы
var pool = new List <IConstant>(_poolCount)
{
null
};
while (_poolCount - pool.Count > 0)
{
switch ((Tags)reader.ReadByte())
{ // Здесь всем методам будем передавать index + 1
case Tags.CONSTANT_Class:
// parse 2byte name_index
pool.Add(new ClassInfo(reader.ReadUInt16()));
break;
case Tags.CONSTANT_Fieldref:
case Tags.CONSTANT_Methodref:
case Tags.CONSTANT_InterfaceMethodref:
// u2 class_index
// u2 name_and_type_index
pool.Add(new FiMeInRef(reader.ReadUInt16(), reader.ReadUInt16()));
break;
case Tags.CONSTANT_String:
// u2 string_index
pool.Add(new StringRef(reader.ReadUInt16()));
break;
case Tags.CONSTANT_Integer:
// u4 bytes
pool.Add(ParseIntegerConstant(reader));
//index += 4;
break;
case Tags.CONSTANT_Float: // Не знаю, что будет с float, попробую не пользоваться формулой s * m * 2**(e-150)
// u4 bytes
pool.Add(ParseFloatConstant(reader));
//index += 4;
break;
case Tags.CONSTANT_Long:
case Tags.CONSTANT_Double:
var pair = ParseLongOrDoubleConstant(reader);
pool.Add(pair.Item1);
pool.Add(pair.Item2);
//index += 8;
break;
case Tags.CONSTANT_NameAndType:
// u2 name_index
// u2 descriptor_index
pool.Add(new NameAndTypeInfo(reader.ReadUInt16(), reader.ReadUInt16()));
break;
case Tags.CONSTANT_Utf8:
var length = reader.ReadUInt16();
var fragment = reader.ReadBytes(length);
pool.Add(ParseUtfStrings(fragment, length));
break;
case Tags.CONSTANT_MethodHandle:
// u1 reference_kind in range(1 to 9)
// u2 reference_index
pool.Add(new MethodHandle(reader.ReadByte(), reader.ReadUInt16())); // Надо бы валидацию
break;
case Tags.CONSTANT_MethodType:
// u2 descriptor_index
pool.Add(new MethodType(reader.ReadUInt16()));
break;
case Tags.CONSTANT_InvokeDynamic:
// u2 bootstrap_method_attr_index
// u2 name_and_type_index
pool.Add(new InvokeDynamic(reader.ReadUInt16(), reader.ReadUInt16()));
break;
}
}
return(pool);
}