public void Throws_Exception_If_Invalid_Features_Response_Received() { MessageSender.SendTransportMessage(TransportMessage.Opened); MessageSender.SendToReceivePipe(StreamHeader.Client()); Assert.Throws <XmppException>(() => MessageSender.SendToReceivePipe(new XmlElement("stream:feature"))); }
/// <summary> /// Reads stream headers described in ECMA-335 24.2.2 Stream header /// </summary> private StreamHeader[] ReadStreamHeaders(ref BlobReader memReader) { // storage header: memReader.ReadUInt16(); int streamCount = memReader.ReadInt16(); var streamHeaders = new StreamHeader[streamCount]; for (int i = 0; i < streamHeaders.Length; i++) { if (memReader.RemainingBytes < COR20Constants.MinimumSizeofStreamHeader) { throw new BadImageFormatException("StreamHeaderTooSmall"); } streamHeaders[i].Offset = memReader.ReadUInt32(); streamHeaders[i].Size = memReader.ReadInt32(); streamHeaders[i].Name = memReader.ReadUtf8NullTerminated(); bool aligned = memReader.TryAlign(4); if (!aligned || memReader.RemainingBytes == 0) { throw new BadImageFormatException("NotEnoughSpaceForStreamHeaderName"); } } return(streamHeaders); }
Task IPreprocessingStep.Execute(IPreprocessingStepCallback callback) { var header = new StreamHeader(sourceFile.Location); var detectedFormatStep = extentions.Items.Select(d => d.DetectFormat(sourceFile, header)).FirstOrDefault(x => x != null); if (detectedFormatStep != null) { callback.YieldNextStep(detectedFormatStep); } else if (IsZip(sourceFile, header)) { callback.YieldNextStep(preprocessingStepsFactory.CreateUnpackingStep(sourceFile)); } else if (IsGzip(sourceFile, header)) { callback.YieldNextStep(preprocessingStepsFactory.CreateGunzippingStep(sourceFile)); } else if (IsTar(sourceFile, header)) { callback.YieldNextStep(preprocessingStepsFactory.CreateUntarStep(sourceFile)); } else { AutodetectFormatAndYield(sourceFile, callback); } return(Task.FromResult(0)); }
//------------------------------------------------- private bool ReadFormatControl(Stream Stream_in) { if ((Stream_in == null)) { return(false); } if ((this._Blocks == null)) { return(false); } BinaryFormatter bf = new BinaryFormatter(); try { Stream_in.Seek(0, SeekOrigin.Begin); this._Header = (StreamHeader)bf.Deserialize(Stream_in); Stream_in.Seek((this._Header.DataOffset + this._Header.DataSize), SeekOrigin.Begin); byte[] inbytes = new byte[Convert.ToInt32((Stream_in.Length - Stream_in.Position) - 1) + 1]; Stream_in.Read(inbytes, 0, inbytes.Length); byte[] outbytes = { }; if (!this._DecodeBytes(null, inbytes, ref outbytes)) { return(false); } MemoryStream ms = new MemoryStream(outbytes); this._Blocks = (ArrayList)bf.Deserialize(ms); } catch (Exception ex) { throw ex; } return(true); }
//------------------------------------------------- public Stream Close(bool Compact_in, bool CloseStream_in) { if ((this._Stream != null)) { if (Compact_in) { if (!this.Compact()) { return(null); } } if (this._BlocksDirty) { if (!this.WriteFormatControl(this._Stream)) { return(null); } } if (CloseStream_in) { if ((this._Stream != null)) { this._Stream.Close(); } } } this._Header = null; this._Blocks = null; this._BlocksDirty = false; Stream stream = this._Stream; this._Stream = null; return(stream); }
private StreamBlock(short streamId, StreamHeader header, byte[] checksum, byte[] data) { _streamId = streamId; _header = header; _checksum = checksum; _data = data; }
private static void PrintStreamHeader(StreamHeader value, int indent) { PrintRawData(value, indent); Print($"Name: {value.DisplayName}", indent); Print($"Offset: {value.Offset:X8}", indent); Print($"Size: {value.Size:X8}", indent); }
public byte[] GetStreamBytes(BinaryReader reader, StreamHeader streamHeader, uint metadataDirectoryAddress, IEnumerable <Section> sections) { var rva = metadataDirectoryAddress + streamHeader.Offset; var fileOffset = BinUtil.RVAToOffset(rva, sections); reader.BaseStream.Seek((long)fileOffset, SeekOrigin.Begin); return(reader.ReadBytes((int)streamHeader.Size)); }
BlobChunkVerificationResultInfo WriteChunksWriteStart() { var result = VerifyEnoughBytesForChunkOrData(kHeaderSize); if (result.IsValid) { mHeader = new StreamHeader(mHeader.FileType); mHeader.Serialize(UnderlyingStream); } return(result); }
public void ModifyD3DTX(DDS_Master dds) //ISSUE HERE WITH DXT5 AND MIP MAPS WITH UPSCALED TEXTURES { mWidth = dds.header.dwWidth; //this is correct mHeight = dds.header.dwHeight; //this is correct mSurfaceFormat = DDS_Functions.Get_T3Format_FromFourCC(dds.header.ddspf.dwFourCC); //this is correct mDepth = dds.header.dwDepth; mNumMipLevels = dds.header.dwMipMapCount; List <byte[]> ddsData = dds.textureData; ddsData.Reverse(); mPixelData.Clear(); //this is correct mPixelData = ddsData; //this is correct StreamHeader newStreamHeader = new StreamHeader() { mRegionCount = (int)dds.header.dwMipMapCount, //this is correct mAuxDataCount = mStreamHeader.mAuxDataCount, //this is correct mTotalDataSize = (int)ByteFunctions.Get2DByteArrayTotalSize(mPixelData) //this is correct }; mStreamHeader = newStreamHeader; //this is correct List <RegionStreamHeader> regionStreamHeader = new List <RegionStreamHeader>(); //this is correct uint[,] mipMapResolutions = DDS_Functions.DDS_CalculateMipResolutions(mNumMipLevels, mWidth, mHeight); bool blockSizeDouble = DDS_Functions.DDS_CompressionBool(dds.header); for (int i = 0; i < mStreamHeader.mRegionCount; i++) { RegionStreamHeader region = new RegionStreamHeader() { mDataSize = (uint)mPixelData[i].Length, mFaceIndex = 0, //NOTE: for cubemap textures this will need to change mMipCount = 1, //NOTE: for cubemap textures this will need to change mMipIndex = (mStreamHeader.mRegionCount - 1) - i, mPitch = DDS_Functions.DDS_ComputePitchValue(mipMapResolutions[mStreamHeader.mRegionCount - i, 0], blockSizeDouble), //this is correct mSlicePitch = mPixelData[i].Length, //this is correct }; regionStreamHeader.Add(region); } regionStreamHeader.Reverse(); mRegionHeaders = regionStreamHeader.ToArray(); UpdateArrayCapacities(); PrintConsole(); }
public StorageStreamNode(HexDocument doc, StreamHeader sh, int streamNumber, DotNetStream knownStream, IMetaData md) : base((ulong)sh.StartOffset, (ulong)sh.EndOffset - 1) { this.StreamNumber = streamNumber; this.StorageStreamType = GetStorageStreamType(knownStream); this.storageStreamVM = new StorageStreamVM(this, doc, StartOffset, (int)(EndOffset - StartOffset + 1 - 8)); var tblStream = knownStream as TablesStream; if (tblStream != null) { this.newChild = new TablesStreamNode(doc, tblStream, md); } }
public StorageStreamNode(HexBuffer buffer, StreamHeader sh, int streamNumber, DotNetStream knownStream, IMetaData md) : base(HexSpan.FromBounds((ulong)sh.StartOffset, (ulong)sh.EndOffset)) { StreamNumber = streamNumber; StorageStreamType = GetStorageStreamType(knownStream); storageStreamVM = new StorageStreamVM(this, buffer, Span.Start, (int)(Span.Length - 8).ToUInt64()); var tblStream = knownStream as TablesStream; if (tblStream != null) { newChild = new TablesStreamNode(buffer, tblStream, md); } }
public void ModifyD3DTX(DDS_Master dds) { mWidth = dds.header.dwWidth; mHeight = dds.header.dwHeight; mSurfaceFormat = DDS_Functions.Get_T3Format_FromFourCC(dds.header.ddspf.dwFourCC); mDepth = dds.header.dwDepth; mNumMipLevels = dds.header.dwMipMapCount; List <byte[]> ddsData = new List <byte[]>(dds.textureData); //this is correct ddsData.Reverse(); //this is correct mPixelData.Clear(); //this is correct mPixelData = ddsData; //this is correct StreamHeader newStreamHeader = new StreamHeader() { mRegionCount = (int)dds.header.dwMipMapCount, mAuxDataCount = mStreamHeader.mAuxDataCount, mTotalDataSize = (int)ByteFunctions.Get2DByteArrayTotalSize(mPixelData) //this is correct }; mStreamHeader = newStreamHeader; RegionStreamHeader[] regionStreamHeader = new RegionStreamHeader[mStreamHeader.mRegionCount]; uint[,] mipMapResolutions = DDS_Functions.DDS_CalculateMipResolutions(mNumMipLevels, mWidth, mHeight); bool blockSizeDouble = DDS_Functions.DDS_CompressionBool(dds.header); for (int i = 0; i < regionStreamHeader.Length; i++) { regionStreamHeader[i] = new RegionStreamHeader() { mDataSize = (uint)mPixelData[i].Length, mFaceIndex = 0, //NOTE: for cubemap textures this will need to change mMipCount = 1, //NOTE: for cubemap textures this will need to change mMipIndex = (regionStreamHeader.Length - 1) - i, //mMipIndex = (regionStreamHeader.Length - 1) - i, mPitch = DDS_Functions.DDS_ComputePitchValue(mipMapResolutions[regionStreamHeader.Length - i, 0], blockSizeDouble), //this is correct mSlicePitch = mPixelData[i].Length, //this is correct }; } mRegionHeaders = regionStreamHeader; UpdateArrayCapacities(); //PrintConsole(); }
//------------------------------------------------- public bool CreateMemoryStream() { this.Close(); this._Header = new StreamHeader(); this._Blocks = new ArrayList(); MemoryStream STM = new MemoryStream(); if (!this.WriteFormatControl(STM)) { return(false); } if (!this.OpenStream(STM)) { return(false); } return(true); }
public void Can_Negotiate_Tls_Feature() { XmlElement sentElement = default; bool? setTlsSend = default; var featuresResponse = new XmlElement("stream:features", new XmlElement("starttls").Xmlns(XmppNamespaces.Tls)); HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(request => sentElement = request); HandlersRegistry.RegisterTransportMessageHandler(TransportMessage.SetTls, () => setTlsSend = true); MessageSender.SendTransportMessage(TransportMessage.Opened); MessageSender.SendToReceivePipe(StreamHeader.Client()); MessageSender.SendToReceivePipe(featuresResponse); Assert.Equal("starttls", sentElement.Name); MessageSender.SendToReceivePipe(new XmlElement("proceed").Xmlns(XmppNamespaces.Tls)); Assert.True(setTlsSend); }
protected static StreamBlock BuildBlock(byte[] rawBlock) { StreamHeader header = (StreamHeader)rawBlock.Skip(HEADER_OFFSET).Take(HEADER_LENGTH).First(); short streamId = BitConverter.ToInt16(rawBlock.Skip(STREAM_ID_OFFSET).Take(STREAM_ID_LENGTH).ToArray(), 0); byte[] checksum = rawBlock.Skip(CHECKSUM_OFFSET).Take(CHECKSUM_LENGTH).ToArray(); if (header.HasFlag(StreamHeader.CACHEABLE)) { StreamBlock block = StreamCache.GetCache(checksum); if (block != null) { return(block); } } MD5 md5 = MD5.Create(); byte[] data = rawBlock.Skip(DATA_OFFSET).ToArray(); byte[] calculatedChecksum = md5.ComputeHash(data); if (!calculatedChecksum.SequenceEqual(checksum)) { throw new InvalidDataException("Checksums did not match when checking data in BuildBlock routine! Calculated: " + BitConverter.ToString(calculatedChecksum) + " | Stored: " + BitConverter.ToString(checksum)); } if (header.HasFlag(StreamHeader.GZIPPED)) { using (GZipStream stream = new GZipStream(new MemoryStream(data), CompressionMode.Decompress)) { byte[] buffer = new byte[256]; using (MemoryStream memory = new MemoryStream()) { int count = 0; do { count = stream.Read(buffer, 0, buffer.Length); if (count > 0) { memory.Write(buffer, 0, count); } }while (count > 0); data = memory.ToArray(); } } } return(new StreamBlock(streamId, header, checksum, data)); }
public byte[] GetStreamBytes(string streamName, BinaryReader r) { StreamHeader hdr = null; foreach (var item in Streams) { if (item.Name == streamName) { hdr = item; break; } } if (hdr == null) { return(null); } return(GetStreamBytes(r, hdr, ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections)); }
//------------------------------------------------- public bool OpenStream(Stream Stream_in) { this.Close(); if (!Stream_in.CanSeek) { return(false); } if (!Stream_in.CanRead) { return(false); } this._Header = new StreamHeader(); this._Blocks = new ArrayList(); if (!this.ReadFormatControl(Stream_in)) { this.Close(); return(false); } this._Stream = Stream_in; return(true); }
//------------------------------------------------- public bool CreateInStream(Stream Stream_in) { this.Close(); this._Header = new StreamHeader(); this._Blocks = new ArrayList(); if (!Stream_in.CanSeek) { return(false); } if (!Stream_in.CanRead) { return(false); } if (!this.WriteFormatControl(Stream_in)) { return(false); } if (!this.OpenStream(Stream_in)) { return(false); } return(true); }
private void Init(byte[] data) { #region Parse PE Header RawFile = new BinaryReader(new MemoryStream(data)); BinaryReader r = new BinaryReader(new MemoryStream(data)); DosHeader = ReadDOSHeader(r); PeHeader = ReadPEHeader(DosHeader.COFFHeaderAddress, r); //Read all of the data PeHeader.Directories = ReadDirectoriesList(PeHeader.DirectoryLength, r); PeHeader.Sections = ReadSectionsList(PeHeader.NumberOfSections, r); #endregion #region Parse Clr header & Strong name hash try { ClrHeader = ReadCLRHeader(r, PeHeader); } catch { Console.WriteLine("No clr header!"); ContainsMetadata = false; return; } //Read the strong name hash ClrStrongNameHash = ReadStrongNameHash(r, ClrHeader.StrongNameSignatureAddress, ClrHeader.StrongNameSignatureSize, PeHeader.Sections); #endregion #region Parse Metadata header //Skip past all of the IL Code, and get tto the metadata header long pos = (long)BinUtil.RVAToOffset(ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); r.BaseStream.Position = pos; ClrMetaDataHeader = new MetadataHeader(); ClrMetaDataHeader.Signature = r.ReadUInt32(); ClrMetaDataHeader.MajorVersion = r.ReadUInt16(); ClrMetaDataHeader.MinorVersion = r.ReadUInt16(); ClrMetaDataHeader.Reserved1 = r.ReadUInt32(); ClrMetaDataHeader.VersionStringLength = r.ReadUInt32(); ClrMetaDataHeader.VersionString = r.ReadNullTermString((int)ClrMetaDataHeader.VersionStringLength); ClrMetaDataHeader.Flags = r.ReadUInt16(); //reserved ClrMetaDataHeader.NumberOfStreams = r.ReadUInt16(); //Simple checks //Debug.Assert(ClrMetaDataHeader.Signature == 0x424A5342); //Debug.Assert(ClrMetaDataHeader.Reserved1 == 0); //Debug.Assert(ClrMetaDataHeader.Flags == 0); #endregion #region Parse Streams //Parse the StreamHeader(s) for (int i = 0; i < ClrMetaDataHeader.NumberOfStreams; i++) { var hdr = new StreamHeader(); hdr.Offset = r.ReadUInt32(); hdr.Size = r.ReadUInt32(); hdr.Name = r.ReadNullTermFourByteAlignedString(); Streams.Add(hdr); } //Parse the #String stream var bytes = GetStreamBytes("#Strings", r); ClrStringsStream = new StringsStream(bytes); //Parse the #US Stream var bytes2 = GetStreamBytes("#US", r); //File.WriteAllBytes("strings", bytes2); ClrUsStream = new USStreamReader(bytes2).Read(); #endregion #region Parse #~ Stream aka Tabels stream //Parse the #~ stream BinaryReader TableStreamR = new BinaryReader(new MemoryStream(GetStreamBytes("#~", r))); ClrMetaDataStreamHeader = ReadHeader(TableStreamR); //Parse the tabels data var numberOfTables = GetTableCount(ClrMetaDataStreamHeader.TablesFlags); ClrMetaDataStreamHeader.TableSizes = new uint[numberOfTables]; for (var i = 0; i < numberOfTables; i++) { ClrMetaDataStreamHeader.TableSizes[i] = TableStreamR.ReadUInt32(); } MetadataReader = new MetadataReader(TableStreamR.BaseStream); BlobStream = GetStreamBytes("#Blob", r); //Parse the tabels Tabels = new Tabels(this); #endregion }
private void Init(byte[] data) { #region Parse PE & Strong name hash RawFile = new BinaryReader(new MemoryStream(data)); BinaryReader r = new BinaryReader(new MemoryStream(data)); DosHeader = ReadDOSHeader(r); PeHeader = ReadPEHeader(DosHeader.COFFHeaderAddress, r); //Read all of the data PeHeader.Directories = ReadDirectoriesList(PeHeader.DirectoryLength, r); PeHeader.Sections = ReadSectionsList(PeHeader.NumberOfSections, r); try { ClrHeader = ReadCLRHeader(r, PeHeader); } catch (Exception ex) { throw new Exception("Error: Invaild metadata: " + ex.Message); } //Read the strong name hash ClrStrongNameHash = ReadStrongNameHash(r, ClrHeader.StrongNameSignatureAddress, ClrHeader.StrongNameSignatureSize, PeHeader.Sections); #endregion #region Parse metadata header //Skip past all of the IL Code, and get tto the metadata header long pos = (long)RelativeVirtualAddressToFileOffset(ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); r.BaseStream.Position = pos; ClrMetaDataHeader = new MetadataHeader(); ClrMetaDataHeader.Signature = r.ReadUInt32(); ClrMetaDataHeader.MajorVersion = r.ReadUInt16(); ClrMetaDataHeader.MinorVersion = r.ReadUInt16(); ClrMetaDataHeader.Reserved1 = r.ReadUInt32(); ClrMetaDataHeader.VersionStringLength = r.ReadUInt32(); ClrMetaDataHeader.VersionString = r.ReadNullTermString((int)ClrMetaDataHeader.VersionStringLength); ClrMetaDataHeader.Flags = r.ReadUInt16(); //reserved ClrMetaDataHeader.NumberOfStreams = r.ReadUInt16(); //Simple checks //Debug.Assert(ClrMetaDataHeader.Signature == 0x424A5342); //Debug.Assert(ClrMetaDataHeader.Reserved1 == 0); //Debug.Assert(ClrMetaDataHeader.Flags == 0); #endregion #region Parse streams //Read all of the tabels List <StreamHeader> Streams = new List <StreamHeader>(); //Parse the StreamHeader(s) for (int i = 0; i < ClrMetaDataHeader.NumberOfStreams; i++) { var hdr = new StreamHeader(); hdr.Offset = r.ReadUInt32(); hdr.Size = r.ReadUInt32(); hdr.Name = r.ReadNullTermString(); //#~ Stream if (hdr.Name.Length == 2) { r.BaseStream.Position += 1; //Skip past the 4 zeros } //#Strings stream else if (hdr.Name.Length == 8) { r.BaseStream.Position += 3; } //#US Stream else if (hdr.Name.Length == 3) { } //#GUID Stream else if (hdr.Name.Length == 5) { r.BaseStream.Position += 2; } Console.WriteLine("Stream: " + hdr.Name + " Size: " + hdr.Size + " Offset: " + hdr.Offset); Streams.Add(hdr); } //Parse the #String stream var bytes = GetStreamBytes(r, Streams[1], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); ClrStringsStream = new StringsStreamReader(bytes).Read(); //Parse the #US Stream var bytes2 = GetStreamBytes(r, Streams[2], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); ClrUsStream = new USStreamReader(bytes2).Read(); #endregion #region Parse #~ Stream //Parse the #~ stream BinaryReader TableStreamR = new BinaryReader(new MemoryStream( GetStreamBytes(r, Streams[0], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections))); ClrMetaDataStreamHeader = ReadHeader(TableStreamR); //Parse the tabels data var numberOfTables = GetTableCount(ClrMetaDataStreamHeader.TablesFlags); ClrMetaDataStreamHeader.TableSizes = new uint[numberOfTables]; for (var i = 0; i < numberOfTables; i++) { ClrMetaDataStreamHeader.TableSizes[i] = TableStreamR.ReadUInt32(); } MetadataReader = new MetadataReader(TableStreamR.BaseStream); //Parse the tabels tabels = new Tabels(this); #endregion }
public void Start(string folder, bool writeStock, bool writeOrders, bool writeTrades, bool writeMessages, HashSet <Security> ticks, int rk) { try { lock (pLock) { // --------------------------------------------------- if (IsRecording) { Status = "Запись уже ведется"; return; } // --------------------------------------------------- streamsCount = 0; if (writeStock) { streamsCount++; } if (writeOrders) { streamsCount++; } if (writeTrades) { streamsCount++; } if (writeMessages) { streamsCount++; } streamsCount += ticks.Count; if (streamsCount == 0) { throw new Exception("Не заданы потоки для записи"); } // --------------------------------------------------- WrittenCount = 0; LastDateTime = DateTime.MinValue; // --------------------------------------------------- baseDateTime = DateTime.UtcNow; if (rk == 0) { FileName = string.Format(FileNameFormat0, baseDateTime.ToLocalTime(), cfg.HistoryFileExt); } if (rk == 1) { FileName = string.Format(FileNameFormat1, baseDateTime.ToLocalTime(), cfg.HistoryFileExt); } if (rk == 2) { FileName = string.Format(FileNameFormat2, baseDateTime.ToLocalTime(), cfg.HistoryFileExt); } fs = new FileStream(folder + "\\" + FileName, FileMode.Create, FileAccess.Write); bw = new BinaryWriter(new DeflateStream(fs, CompressionMode.Compress)); DataFile.WriteHeader(bw, new DataFileHeader( cfg.FullProgName, string.Empty, baseDateTime, streamsCount)); // --------------------------------------------------- streamsCount = 0; StreamHeader sh = new StreamHeader(StreamType.Stock, new Security(cfg.u.SecCode, cfg.u.ClassCode), cfg.u.PriceRatio, cfg.u.PriceStep); if (writeStock) { stockId = streamsCount++; DataFile.WriteStreamHeader(bw, sh); lastQuotes = new Quote[0]; this.writeStock = true; } if (writeOrders) { orderId = streamsCount++; sh.Type = StreamType.Orders; DataFile.WriteStreamHeader(bw, sh); this.writeOrders = true; } if (writeTrades) { tradeId = streamsCount++; sh.Type = StreamType.Trades; DataFile.WriteStreamHeader(bw, sh); this.writeTrades = true; } if (writeMessages) { msgId = streamsCount++; sh.Type = StreamType.Messages; DataFile.WriteStreamHeader(bw, sh); this.writeMessages = true; } if (ticks.Count > 0) { tickIds = new Dictionary <int, int>(ticks.Count); sh = new StreamHeader(StreamType.Ticks); foreach (Security s in ticks) { tickIds.Add(s.GetKey(), streamsCount++); sh.Security = s; DataFile.WriteStreamHeader(bw, sh); } } // --------------------------------------------------- } Status = "Запись..."; IsRecording = true; } catch (Exception e) { SetError(e.Message); } }
/// <summary> /// Deserializes a D3DTX Object from a byte array. /// </summary> /// <param name="data"></param> /// <param name="bytePointerPosition"></param> public D3DTX_V7(BinaryReader reader, bool showConsole = false) { mVersion = reader.ReadInt32(); //mVersion [4 bytes] mSamplerState_BlockSize = reader.ReadInt32(); //mSamplerState Block Size [4 bytes] mSamplerState = new T3SamplerStateBlock() //mSamplerState [4 bytes] { mData = reader.ReadUInt32() }; mPlatform_BlockSize = reader.ReadInt32(); //mPlatform Block Size [4 bytes] mPlatform = EnumPlatformType.GetPlatformType(reader.ReadInt32()); //mPlatform [4 bytes] mName_BlockSize = reader.ReadInt32(); //mName Block Size [4 bytes] //mName block size (size + string len) mName = ByteFunctions.ReadString(reader); //mName [x bytes] mImportName_BlockSize = reader.ReadInt32(); //mImportName Block Size [4 bytes] //mImportName block size (size + string len) mImportName = ByteFunctions.ReadString(reader); //mImportName [x bytes] (this is always 0) mImportScale = reader.ReadSingle(); //mImportScale [4 bytes] mToolProps = new ToolProps() //mToolProps [1 byte] { mbHasProps = reader.ReadBoolean() }; mNumMipLevels = reader.ReadUInt32(); //mNumMipLevels [4 bytes] mWidth = reader.ReadUInt32(); //mWidth [4 bytes] mHeight = reader.ReadUInt32(); //mHeight [4 bytes] mSurfaceFormat = T3TextureBase_Functions.GetSurfaceFormat(reader.ReadInt32()); //mSurfaceFormat [4 bytes] mTextureLayout = T3TextureBase_Functions.GetTextureLayout(reader.ReadInt32()); //mTextureLayout [4 bytes] mSurfaceGamma = T3TextureBase_Functions.GetSurfaceGamma(reader.ReadInt32()); //mSurfaceGamma [4 bytes] mSurfaceMultisample = T3TextureBase_Functions.GetSurfaceMultisample(reader.ReadInt32()); //mSurfaceMultisample [4 bytes] mResourceUsage = T3TextureBase_Functions.GetResourceUsage(reader.ReadInt32()); //mResourceUsage [4 bytes] mType = T3Texture_Functions.GetTextureType(reader.ReadInt32()); //mType [4 bytes] mSwizzleSize = reader.ReadInt32(); //mSwizzleSize [4 bytes] mSwizzle = new RenderSwizzleParams() //mSwizzle [4 bytes] { mSwizzle1 = (char)reader.ReadByte(), mSwizzle2 = (char)reader.ReadByte(), mSwizzle3 = (char)reader.ReadByte(), mSwizzle4 = (char)reader.ReadByte() }; mNormalMapFormat = reader.ReadInt32(); //mNormalMapFormat [4 bytes] mHDRLightmapScale = reader.ReadSingle(); //mHDRLightmapScale [4 bytes] mToonGradientCutoff = reader.ReadSingle(); //mToonGradientCutoff [4 bytes] mAlphaMode = T3Texture_Functions.GetAlphaMode(reader.ReadInt32()); //mAlphaMode [4 bytes] mColorMode = T3Texture_Functions.GetColorMode(reader.ReadInt32()); //mColorMode [4 bytes] mUVOffset = new Vector2() //mUVOffset [8 bytes] { x = reader.ReadSingle(), //[4 bytes] y = reader.ReadSingle() //[4 bytes] }; mUVScale = new Vector2() //mUVScale [8 bytes] { x = reader.ReadSingle(), //[4 bytes] y = reader.ReadSingle() //[4 bytes] }; //--------------------------mArrayFrameNames-------------------------- mArrayFrameNames_ArrayCapacity = reader.ReadUInt32(); //mArrayFrameNames DCArray Capacity [4 bytes] mArrayFrameNames_ArrayLength = reader.ReadInt32(); //mArrayFrameNames DCArray Length [4 bytes] //ADD 1 BECAUSE COUNTING STARTS AT 0 mArrayFrameNames = new List <Symbol>(); for (int i = 0; i < mArrayFrameNames_ArrayLength; i++) { Symbol newSymbol = new Symbol() { mCrc64 = reader.ReadUInt64() }; mArrayFrameNames.Add(newSymbol); } //--------------------------mToonRegions-------------------------- mToonRegions_ArrayCapacity = reader.ReadUInt32(); //mToonRegions DCArray Capacity [4 bytes] mToonRegions_ArrayLength = reader.ReadInt32(); //mToonRegions DCArray Length [4 bytes] mToonRegions = new T3ToonGradientRegion[mToonRegions_ArrayLength]; for (int i = 0; i < mToonRegions_ArrayLength; i++) { mToonRegions[i] = new T3ToonGradientRegion() { mColor = new Color() { r = reader.ReadSingle(), //[4 bytes] g = reader.ReadSingle(), //[4 bytes] b = reader.ReadSingle(), //[4 bytes] a = reader.ReadSingle() //[4 bytes] }, mSize = reader.ReadSingle() //[4 bytes] }; } //--------------------------StreamHeader-------------------------- mStreamHeader = new StreamHeader() { mRegionCount = reader.ReadInt32(), //[4 bytes] mAuxDataCount = reader.ReadInt32(), //[4 bytes] mTotalDataSize = reader.ReadInt32() //[4 bytes] }; //--------------------------mRegionHeaders-------------------------- mRegionHeaders = new RegionStreamHeader[mStreamHeader.mRegionCount]; for (int i = 0; i < mStreamHeader.mRegionCount; i++) { mRegionHeaders[i] = new RegionStreamHeader() { mFaceIndex = reader.ReadInt32(), //[4 bytes] mMipIndex = reader.ReadInt32(), //[4 bytes] mMipCount = reader.ReadInt32(), //[4 bytes] mDataSize = reader.ReadUInt32(), //[4 bytes] mPitch = reader.ReadInt32(), //[4 bytes] mSlicePitch = reader.ReadInt32() //[4 bytes] }; } //-----------------------------------------D3DTX HEADER END----------------------------------------- //--------------------------STORING D3DTX IMAGE DATA-------------------------- mPixelData = new List <byte[]>(); for (int i = 0; i < mStreamHeader.mRegionCount; i++) { int dataSize = (int)mRegionHeaders[i].mDataSize; byte[] imageData = reader.ReadBytes(dataSize); mPixelData.Add(imageData); } if (showConsole) { PrintConsole(); } }
FileInfo Get_FileInfo(string name) { foreach (var file in _directory.GetFiles()) if (file.Name == name) return file; var path = Path.Combine(_directory.FullName, name); using (var stream = File.Create(path)) { var header = new StreamHeader { Index = StreamHeader.SizeInBytes(), Timestamp = DateTime.Now }; using (var writer = new BinaryWriter(stream)) header.Serialize(writer); } return new FileInfo(path); }
static void Main(string[] args) { string dllPath = String.Empty; if (args.Length > 0) { dllPath = args[0]; if (File.Exists(dllPath)) { ModuleContext context = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(dllPath); Metadata metadata = module.Metadata; //MetaHeader MetadataHeader metadataHeader = metadata.MetadataHeader; //存储流Header数量 int count = metadataHeader.StreamHeaders.Count; //Cor20头 ImageCor20Header imageCor20Header = metadata.ImageCor20Header; int cbOffeset = 0x208; //cb偏移 int Metadata_VirtualAddress = (int)imageCor20Header.Metadata.VirtualAddress; //Metadata RVA int MetadataOffeset = Metadata_VirtualAddress - 0x1E00; //metadata文件偏移 int stringHeaderSize = 0; //stringHeader size int iMajorVerOffeset = MetadataOffeset + 0x4; int iMinorVerOffeset = iMajorVerOffeset + 0x2; int VersionStringLOffeset = MetadataOffeset + 0xC; int stringHeaderOffeset = MetadataOffeset + 0x30; int pe1 = 0x82; int pe2 = 0x83; int nrs = 0xF4; for (int i = 0; i < count; i++) { StreamHeader header = metadataHeader.StreamHeaders[i]; if (header.Name.Contains("Strings")) { stringHeaderSize = (int)header.StreamSize; } } byte[] buffer = File.ReadAllBytes(dllPath); buffer[pe1] = 0x2E; buffer[pe2] = 0x2E; buffer[nrs] = 0xF; buffer[cbOffeset] = 0x88; buffer[iMajorVerOffeset] = 0x2; buffer[iMinorVerOffeset] = 0x2; buffer[VersionStringLOffeset] = 0xB; byte temp = buffer[stringHeaderOffeset]; buffer[stringHeaderOffeset] = buffer[stringHeaderOffeset + 1]; buffer[stringHeaderOffeset + 1] = buffer[stringHeaderOffeset + 2]; buffer[stringHeaderOffeset + 2] = temp; string savePath = dllPath.Replace(".dll", "_encrypt.dll"); File.WriteAllBytes(savePath, buffer); Console.ReadKey(); } else { Console.WriteLine("文件不存在!\n按任意键退出!"); Console.ReadLine(); } } else { Console.WriteLine("文件输入有误!\n按任意键退出!"); Console.ReadLine(); } }
private void OnStreamRecived(StreamHeader streamHeader, byte[] content) { throw new NotImplementedException(); }
public void StreamEnqueue(StreamHeader streamHeader) => _streamHeaderQueue.Enqueue(streamHeader);
/// <summary> /// 构造器 /// </summary> /// <param name="metadata">元数据</param> /// <param name="header">元数据流头</param> public UnknownHeap(IMetadata metadata, StreamHeader header) : base(metadata, header) { }
public BlobTransportStream(string fileType = "") { mHeader = new StreamHeader(fileType); }
async Task WriteHeader(StreamHeader header, string name) { using (var buffer = CreateMemoryStream()) { using (var writer = new BinaryWriter(buffer, Encoding.UTF8, true)) { header.Serialize(writer); writer.Flush(); } buffer.Seek(0, SeekOrigin.Begin); using (var stream = Open_Stream_For_Writing(name)) { await buffer.CopyToAsync(stream); stream.Flush(); } } }
public MetadataStream Parse(DataInterface file, AssemblyLoader al, bool fail_refs = true, bool is_pdb = false) { var m = new MetadataStream(); m.al = al; long mroot_offset; if (is_pdb) { mroot_offset = 0; pdbf = true; } else { pefh = new PE_File_Header(); uint pefh_start = file.ReadUInt(0x3c) + 4; uint pesig = file.ReadUInt((int)pefh_start - 4); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: PE Signature: " + pesig.ToString("X8")); pefh.NumberOfSections = file.ReadUShort((int)pefh_start + 2); pefh.Sections = new SectionHeader[pefh.NumberOfSections]; TimeSpan t = new TimeSpan(0, 0, (int)(file.ReadUInt((int)pefh_start + 4) & 0x7fffffff)); // csc /deterministic sets top bit - ignore for timestamp purposes System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: t: " + ((int)file.ReadUInt((int)pefh_start + 4)).ToString()); pefh.TimeDateStamp = new DateTime(1970, 1, 1) + t; pefh.OptHeaderSize = file.ReadUShort((int)pefh_start + 16); if (pefh.OptHeaderSize < 224) { throw new Exception("PE optional header too small"); } pefh.Chars = file.ReadUShort((int)pefh_start + 18); if ((pefh.Chars & 0x3) != 0x2) { System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: Invalid PE file header characteristics: " + pefh.Chars.ToString()); System.Diagnostics.Debugger.Break(); throw new Exception("Invalid PE file header characteristics"); } int pe32plusoffset = 0; ushort magic = file.ReadUShort((int)pefh_start + 20); if (magic == 0x20b) { pe32plusoffset = 16; } pefh.CliHeader = new DataDir(); pefh.CliHeader.RVA = file.ReadUInt((int)pefh_start + 228 + pe32plusoffset); pefh.CliHeader.Size = file.ReadUInt((int)pefh_start + 232 + pe32plusoffset); // Read the section headers uint sections_start = pefh_start + 20 + pefh.OptHeaderSize; for (uint i = 0; i < pefh.NumberOfSections; i++) { uint s_start = sections_start + i * 40; pefh.Sections[i] = new SectionHeader(); char[] w_str = new char[9]; for (int j = 0; j < 8; j++) { w_str[j] = (char)file.ReadByte((int)s_start + j); } w_str[8] = '\0'; pefh.Sections[i].Name = new String(w_str); pefh.Sections[i].Name = pefh.Sections[i].Name.Remove(pefh.Sections[i].Name.IndexOf("\0")); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: section name: " + pefh.Sections[i].Name + "\n"); pefh.Sections[i].VSize = file.ReadUInt((int)s_start + 8); pefh.Sections[i].VAddress = file.ReadUInt((int)s_start + 12); pefh.Sections[i].PSize = file.ReadUInt((int)s_start + 16); pefh.Sections[i].PAddress = file.ReadUInt((int)s_start + 20); pefh.Sections[i].Chars = file.ReadUInt((int)s_start + 36); } // Read the Cli header if (pefh.CliHeader.RVA == 0) { return(null); } long clih_offset = ResolveRVA(pefh.CliHeader.RVA); clih = new Cli_Header(); clih.Metadata.RVA = file.ReadUInt((int)clih_offset + 8); clih.Metadata.Size = file.ReadUInt((int)clih_offset + 12); clih.EntryPointToken = file.ReadUInt((int)clih_offset + 20); clih.Resources.RVA = file.ReadUInt((int)clih_offset + 24); clih.Resources.Size = file.ReadUInt((int)clih_offset + 28); m.entry_point_token = clih.EntryPointToken; System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: CLI header parsed"); // First, read the metadata root mroot_offset = ResolveRVA(clih.Metadata.RVA); } uint sig = file.ReadUInt((int)mroot_offset); if (sig != 0x424A5342) { throw new Exception("Invalid metadata root"); } uint vstr_len = file.ReadUInt((int)mroot_offset + 12); m.VersionString = ReadSZ(file, (int)mroot_offset + 16); ushort nstr = file.ReadUShort((int)mroot_offset + 16 + (int)vstr_len + 2); int cur_offset = (int)mroot_offset + 16 + (int)vstr_len + 4; // Now, read the stream headers for (ushort i = 0; i < nstr; i++) { StreamHeader sh = new StreamHeader(); sh.Offset = file.ReadUInt(cur_offset); sh.FileOffset = ResolveRVA((is_pdb ? 0 : clih.Metadata.RVA) + sh.Offset); sh.Size = file.ReadUInt(cur_offset + 4); cur_offset += 8; StringBuilder sb = new StringBuilder(); while (true) { byte strb = file.ReadByte(cur_offset++); if (strb == 0) { break; } else { sb.Append((char)strb); } } while ((cur_offset & 0x3) != 0) { cur_offset++; } sh.Name = sb.ToString(); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: stream name: " + sh.Name); sh.di = file.Clone((int)sh.FileOffset); if (sh.Name == "#Strings") { m.sh_string = sh; } else if (sh.Name == "#US") { m.sh_us = sh; } else if (sh.Name == "#GUID") { m.sh_guid = sh; } else if (sh.Name == "#Blob") { m.sh_blob = sh; } else if (sh.Name == "#~") { m.sh_tables = sh; } else if (sh.Name == "#Pdb") { m.sh_pdb = sh; } else { System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: unknown table \"" + sh.Name + "\""); throw new Exception("Unknown metadata table"); } } // Parse tables if (m.sh_tables != null) { var di = m.sh_tables.di; var maj = di.ReadByte(4); var min = di.ReadByte(5); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: parsing tables"); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: metadata table schema v" + maj.ToString() + "." + min.ToString()); // Determine size of indices into the heaps var heapsizes = di.ReadByte(6); if ((heapsizes & 0x1) == 0x1) { m.wide_string = true; } if ((heapsizes & 0x2) == 0x2) { m.wide_guid = true; } if ((heapsizes & 0x4) == 0x4) { m.wide_blob = true; } // Get list of valid tables var valid = di.ReadULong(8); int valid_count = 0; List <int> valid_tables = new List <int>(); for (int i = 0; i < 64; i++) { if (((valid >> i) & 0x1) == 0x1) { m.valid_tables[i] = true; valid_count++; valid_tables.Add(i); } } // Get number of rows in each table int table_id = 0; foreach (var valid_table in valid_tables) { m.table_rows[valid_table] = (int)di.ReadUInt(24 + 4 * table_id++); } // Interpret the schema of each table foreach (var valid_table in valid_tables) { InterpretSchema(valid_table, m); } // Determine start offsets of each table int offset = 24 + 4 * valid_count; foreach (var valid_table in valid_tables) { m.table_offsets[valid_table] = offset; offset += m.table_rows[valid_table] * m.table_entry_size[valid_table]; } } m.pef = this; m.file = file; /* Get this assembly name */ if (m.table_rows[MetadataStream.tid_Assembly] == 1) { m.assemblyName = m.GetStringEntry(MetadataStream.tid_Assembly, 1, 7); // Handle dotnet coreclr mscorlib having a different name if (m.assemblyName == "System.Private.CoreLib") { m.assemblyName = "mscorlib"; } System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: current assembly is " + m.assemblyName); } /* Load up all referenced assemblies */ m.referenced_assemblies = new MetadataStream[m.table_rows[MetadataStream.tid_AssemblyRef]]; for (int i = 1; i <= m.table_rows[MetadataStream.tid_AssemblyRef]; i++) { var ass_name = m.GetStringEntry(MetadataStream.tid_AssemblyRef, i, 6); var maj = (int)m.GetIntEntry(MetadataStream.tid_AssemblyRef, i, 0); var min = (int)m.GetIntEntry(MetadataStream.tid_AssemblyRef, i, 1); var build = (int)m.GetIntEntry(MetadataStream.tid_AssemblyRef, i, 2); var rev = (int)m.GetIntEntry(MetadataStream.tid_AssemblyRef, i, 3); if (ass_name == "netstandard") { ass_name = "mscorlib"; maj = -1; } System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: loading referenced assembly " + ass_name); if ((m.referenced_assemblies[i - 1] = al.GetAssembly(ass_name, maj, min, build, rev)) == null && fail_refs) { var ale = new AssemblyLoadException(); ale.ReferencedAssembly = new AssemblyLoadException.ALEAssembly { Name = ass_name, Major = maj, Minor = min, Revision = rev, Build = build }; ale.CurrentAssembly = new AssemblyLoadException.ALEAssembly { Name = m.AssemblyName, Major = m.MajorVersion, Minor = m.MinorVersion, Revision = m.RevisionVersion, Build = m.BuildVersion }; foreach (var la in al.LoadedAssemblies) { var cla = al.GetAssembly(la); var clale = new AssemblyLoadException.ALEAssembly { Name = cla.AssemblyName, Major = cla.MajorVersion, Minor = cla.MinorVersion, Revision = cla.RevisionVersion, Build = cla.BuildVersion }; ale.CurrentlyLoadedAssemblies.Add(clale); } throw ale; } } m.PatchMethodDefOwners(); m.PatchFieldDefOwners(); m.PatchFieldRVAs(); m.PatchClassLayouts(); m.PatchFieldConstants(); m.PatchGTypes(); if (m.assemblyName == "mscorlib") { m.is_corlib = true; m.PatchSimpleTypes(); } m.PatchNestedTypes(); m.PatchCustomAttrs(); m.LoadBuiltinTypes(); System.Diagnostics.Debugger.Log(0, "metadata", "PEFile.Parse: parsing complete"); /* Load up a .pdb sidecar file if necessary */ if (m.sh_pdb != null) { m.pdb = m; } else { var fname = file.Name; if (fname != null) { if (fname.EndsWith(".dll") || fname.EndsWith(".exe")) { fname = fname.Substring(0, fname.Length - 4); } var pdbf = al.LoadAssembly(fname + ".pdb"); if (pdbf != null) { var pef = new metadata.PEFile(); try { m.pdb = pef.Parse(pdbf, al, true, true); } catch (Exception) { m.pdb = null; } } } } return(m); }
/// <summary> /// Reads the audio properties from the file represented by /// the current instance. /// </summary> /// <param name="start"> /// A <see cref="long" /> value containing the seek position /// at which the tags end and the media data begins. /// </param> /// <param name="end"> /// A <see cref="long" /> value containing the seek position /// at which the media data ends and the tags begin. /// </param> /// <param name="propertiesStyle"> /// A <see cref="ReadStyle" /> value specifying at what level /// of accuracy to read the media properties, or <see /// cref="ReadStyle.None" /> to ignore the properties. /// </param> /// <returns> /// A <see cref="TagLib.Properties" /> object describing the /// media properties of the file represented by the current /// instance. /// </returns> protected override Properties ReadProperties (long start, long end, ReadStyle propertiesStyle) { StreamHeader header = new StreamHeader (header_block, end - start); return new Properties (TimeSpan.Zero, header); }
public void ClientStreamEnqueue(ClientSocket clientSocket, StreamHeader streamHeader) => _ahemClients[clientSocket.IPAddress].StreamEnqueue(streamHeader);