/// <summary>Read a multi-byte CString from an endian stream</summary> /// <param name="s">Endian stream to read from</param> /// <param name="ms">Stream to write the character's bytes to</param> void ReadCStringMultiByte(IO.EndianReader s, System.IO.MemoryStream ms) { byte[] characters; if (!mStorage.IsFixedLength) { characters = new byte[mNullCharacterSize]; while (!ReadStringMultiByteIsNull(s.ByteOrder, s.Read(characters), 0)) { ms.Write(characters, 0, characters.Length); } } else { characters = s.ReadBytes(mFixedLengthByteLength); int x; for (x = 0; x < characters.Length - mNullCharacterSize; x += mNullCharacterSize) { if (ReadStringMultiByteIsNull(s.ByteOrder, characters, x)) { break; } } ms.Write(characters, 0, x); } }
public void Read(IO.EndianReader s) { s.Owner = this; Flags = s.Read(FileFlagsStreamer.Instance); Version = s.ReadUInt16(); if (Version != kVersion) { throw new IO.VersionMismatchException(s.BaseStream, kVersion, Version); } Read(s, EnumFlags.Test(Flags, FileFlags.EncryptHeader), Header, MediaHeader.kSizeOf); GenerateHash(); if (EnumFlags.Test(Flags, FileFlags.CompressContent)) { using (var cs = new CompressedStream(true)) { Read(s, EnumFlags.Test(Flags, FileFlags.EncryptContent), cs, userKey: Header.DataCryptKey, readLeftovers: ReadLeftovers); cs.Decompress(); Content = cs.UncompressedData; } } else { Content = s.ReadBytes((int)(s.BaseStream.Length - s.BaseStream.Position)); } }
void ReadBitStream(IO.EndianReader s, byte[] hashBuffer) { int max_bit_stream_size = GetBitStreamSize(); bool is_probably_from_mcc = hashBuffer.EqualsZero(); byte[] bs_bytes; using (var hasher = Program.GetGen3RuntimeDataHasher()) { int bs_length = ReadBitStreamSize(s, hasher, max_bit_stream_size, is_probably_from_mcc); bs_bytes = new byte[IntegerMath.Align(IntegerMath.kInt32AlignmentBit, bs_length)]; s.Read(bs_bytes, bs_length); hasher.TransformFinalBlock(bs_bytes, 0, bs_length); InvalidData = hasher.Hash.EqualsArray(hashBuffer) == false; } if (RequireValidHashes && InvalidData) { Data = null; } else { using (var ms = new System.IO.MemoryStream(bs_bytes)) using (var bs = new IO.BitStream(ms, System.IO.FileAccess.Read, streamName: "GameVariant")) { bs.StreamMode = System.IO.FileAccess.Read; Data.Serialize(bs); } } }
public void Read(XmbFile xmb, XmbFileContext xmbContext, IO.EndianReader s) { s.Read(out RootElementIndex); XmbVariantSerialization.Read(s, out NameVariant); XmbVariantSerialization.Read(s, out InnerTextVariant); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } #region Attributes header int count; s.Read(out count); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } s.ReadVirtualAddress(out mAttributesOffset); Attributes = new List <KeyValuePair <XmbVariant, XmbVariant> >(count); #endregion #region Children header s.Read(out count); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } s.ReadVirtualAddress(out mChildrenOffset); ChildrenIndices = new List <int>(count); #endregion if (NameVariant.HasUnicodeData || InnerTextVariant.HasUnicodeData) { xmb.mHasUnicodeStrings = true; } }
static int ReadBitStreamSize(IO.EndianReader s, System.Security.Cryptography.ICryptoTransform hasher, int maxBitStreamSize, bool isProbablyFromMcc) { byte[] bitstream_size_bytes = new byte[sizeof(int)]; s.Read(bitstream_size_bytes); hasher.TransformBlock(bitstream_size_bytes, 0, bitstream_size_bytes.Length, null, 0); if (!s.ByteOrder.IsSameAsRuntime()) { Bitwise.ByteSwap.SwapData(Bitwise.ByteSwap.kInt32Definition, bitstream_size_bytes); } int assumed_size = BitConverter.ToInt32(bitstream_size_bytes, 0); int size = assumed_size; bool size_was_in_range_after_forced_byte_swap = false; if (isProbablyFromMcc) { size = Bitwise.ByteSwap.SwapInt32(size); } else if (assumed_size < 0 || assumed_size > maxBitStreamSize) { size = Bitwise.ByteSwap.SwapInt32(size); if (size <= maxBitStreamSize) { size_was_in_range_after_forced_byte_swap = true; } else { throw new System.IO.InvalidDataException(string.Format( "Invalid bitstream size {0}, data is probably corrupt. Max size is {1}", assumed_size.ToString("X8"), maxBitStreamSize.ToString("X8"))); } } Util.MarkUnusedVariable(ref size_was_in_range_after_forced_byte_swap); return(size); }
public void Read(IO.EndianReader s) { switch (Type) { case XmbVariantType.Int: s.Read(out Int); break; case XmbVariantType.Single: s.Read(out Single); break; case XmbVariantType.Double: s.Read(out Double); break; case XmbVariantType.String: String = s.ReadString(IsUnicode ? kUnicodeEncoding : kAnsiEncoding); break; case XmbVariantType.Vector: if (VectorLength >= 1) { s.Read(out Vector4d.X); } if (VectorLength >= 2) { s.Read(out Vector4d.Y); } if (VectorLength >= 3) { s.Read(out Vector4d.Z); } if (VectorLength >= 4) { s.Read(out Vector4d.W); } break; default: throw new KSoft.Debug.UnreachableException(Type.ToString()); } }
void ReadLeftovers(IO.EndianReader er) { PaddingBytes = new byte[(int)(er.BaseStream.Length - er.BaseStream.Position)]; er.Read(PaddingBytes, 0, PaddingBytes.Length); }