public void PersistentVarFileInfo() { // Prepare mock data. var versionInfo = new VersionInfoResource(); var varFileInfo = new VarFileInfo(); var table = new VarTable(); for (ushort i = 0; i < 10; i++) { table.Values.Add(i); } varFileInfo.Tables.Add(table); versionInfo.AddEntry(varFileInfo); // Serialize. var tempStream = new MemoryStream(); versionInfo.Write(new BinaryStreamWriter(tempStream)); // Reload. var infoReader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newVersionInfo = VersionInfoResource.FromReader(ref infoReader); // Verify. var newVarFileInfo = newVersionInfo.GetChild <VarFileInfo>(VarFileInfo.VarFileInfoKey); Assert.NotNull(newVarFileInfo); Assert.Single(newVarFileInfo.Tables); var newTable = newVarFileInfo.Tables[0]; Assert.Equal(table.Values, newTable.Values); }
public void PreserveMetadataNoChange() { var peFile = PEFile.FromBytes(Properties.Resources.HelloWorld); var peImage = PEImage.FromFile(peFile); var metadata = peImage.DotNetDirectory.Metadata; using var tempStream = new MemoryStream(); metadata.Write(new BinaryStreamWriter(tempStream)); var reader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newMetadata = new SerializedMetadata(new PEReaderContext(peFile), ref reader); Assert.Equal(metadata.MajorVersion, newMetadata.MajorVersion); Assert.Equal(metadata.MinorVersion, newMetadata.MinorVersion); Assert.Equal(metadata.Reserved, newMetadata.Reserved); Assert.Equal(metadata.VersionString, newMetadata.VersionString); Assert.Equal(metadata.Flags, newMetadata.Flags); Assert.Equal(metadata.Streams.Count, newMetadata.Streams.Count); for (int i = 0; i < metadata.Streams.Count; i++) { var oldStream = metadata.Streams[i]; var newStream = newMetadata.Streams[i]; Assert.Equal(oldStream.Name, newStream.Name); var oldData = oldStream.CreateReader().ReadToEnd(); var newData = newStream.CreateReader().ReadToEnd(); Assert.Equal(oldData, newData); } }
public void NewForkTooLong() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); Assert.Throws <EndOfStreamException>(() => reader.ForkAbsolute(6, 4)); }
public void NewForkInvalidStart() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); Assert.Throws <ArgumentOutOfRangeException>(() => reader.ForkAbsolute(9, 3)); }
public void EmptyArray() { var reader = ByteArrayDataSource.CreateReader(new byte[0]); Assert.Equal(0u, reader.Length); Assert.Throws <EndOfStreamException>(() => reader.ReadByte()); Assert.Equal(0, reader.ReadBytes(new byte[10], 0, 10)); }
public void ForkReadsSameData() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); var fork = reader.ForkAbsolute(0, 2); Assert.Equal(0x0201, fork.ReadUInt16()); }
public void ForkStartAtMiddle() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); var fork = reader.ForkAbsolute(4, 2); Assert.Equal(0x0605, fork.ReadUInt16()); }
public void ForkOfFork() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); var fork = reader.ForkAbsolute(2, 4); var fork2 = fork.ForkAbsolute(3, 2); Assert.Equal(0x04, fork2.ReadByte()); }
public void ReadInt16() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x80, 0x02, 0x80 }); Assert.Equal((ushort)0x8001, reader.ReadUInt16()); Assert.Equal(2u, reader.Offset); Assert.Equal((short)-32766, reader.ReadInt16()); Assert.Equal(4u, reader.Offset); }
public void ReadInt32() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x04, 0x03, 0x02, 0x81, 0x08, 0x07, 0x06, 0x85 }); Assert.Equal(0x81020304u, reader.ReadUInt32()); Assert.Equal(4u, reader.Offset); Assert.Equal(-2063202552, reader.ReadInt32()); Assert.Equal(8u, reader.Offset); }
public void ReadInt64() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x80, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x88, }); Assert.Equal(0x8001020304050607ul, reader.ReadUInt64()); Assert.Equal(8u, reader.Offset); Assert.Equal(-8644366967197856241, reader.ReadInt64()); Assert.Equal(16u, reader.Offset); }
public void NewForkSubRange() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); var fork = reader.ForkAbsolute(2, 3); Assert.Equal(2u, fork.StartOffset); Assert.Equal(2u, fork.Offset); Assert.Equal(3u, fork.Length); }
public static void AssertWriteThenReadIsSame <TRow>(TRow expected, SerializedMetadataTable <TRow> .ReadRowExtendedDelegate readRow) where TRow : struct, IMetadataRow { var tablesStream = new TablesStream(); var table = tablesStream.GetTable <TRow>(); using var tempStream = new MemoryStream(); expected.Write(new BinaryStreamWriter(tempStream), table.Layout); var reader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newRow = readRow(new PEReaderContext(new PEFile()), ref reader, table.Layout); Assert.Equal(expected, newRow); }
public void ForkMovesIndependentOfOriginal() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); var fork = reader.ForkAbsolute(0, 2); fork.ReadUInt16(); Assert.Equal(0u, reader.Offset); Assert.Equal(2u, fork.Offset); }
public void ReadByte() { var reader = ByteArrayDataSource.CreateReader(new byte[] { 0x80, 0x80 }); Assert.Equal((byte)0x80, reader.ReadByte()); Assert.Equal(1u, reader.Offset); Assert.Equal((sbyte)-128, reader.ReadSByte()); Assert.Throws <EndOfStreamException>(() => reader.ReadByte()); }
public void PersistentConstructor() { var module = ModuleDefinition.FromFile(typeof(CustomAttributesTestClass).Assembly.Location); using var stream = new MemoryStream(); module.Write(stream); module = ModuleDefinition.FromReader(ByteArrayDataSource.CreateReader(stream.ToArray())); var type = module.TopLevelTypes.First(t => t.Name == nameof(CustomAttributesTestClass)); Assert.All(type.CustomAttributes, a => Assert.Equal(nameof(TestCaseAttribute), a.Constructor.DeclaringType.Name)); }
private static MethodDefinition LookupMethod(string methodName, bool rebuild) { var module = ModuleDefinition.FromFile(typeof(SecurityAttributes).Assembly.Location); if (rebuild) { var stream = new MemoryStream(); module.Write(stream); module = ModuleDefinition.FromReader(ByteArrayDataSource.CreateReader(stream.ToArray())); } var type = module.TopLevelTypes.First(t => t.Name == nameof(SecurityAttributes)); return(type.Methods.First(m => m.Name == methodName)); }
public void PersistentStrongNamePublicKey() { using var rsa = RSA.Create(); var rsaParameters = rsa.ExportParameters(true); var publicKey = new StrongNamePublicKey(rsaParameters); using var tempStream = new MemoryStream(); publicKey.Write(new BinaryStreamWriter(tempStream)); var reader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newPublicKey = StrongNamePublicKey.FromReader(ref reader); Assert.Equal(publicKey.Modulus, newPublicKey.Modulus); Assert.Equal(publicKey.PublicExponent, newPublicKey.PublicExponent); }
public static void ReadLocalVariables(CilMethodBody methodBody, MethodDefinition method, byte[] localSig) { if (!(method.Module is SerializedModuleDefinition module)) { throw new ArgumentException("Method body should reference a serialized module."); } var reader = ByteArrayDataSource.CreateReader(localSig); var localsSignature = (LocalVariablesSignature)CallingConventionSignature.FromReader( new BlobReadContext(module.ReaderContext), ref reader); for (int i = 0; i < localsSignature?.VariableTypes.Count; i++) { methodBody.LocalVariables.Add(new CilLocalVariable(localsSignature.VariableTypes[i])); } }
/// <summary> /// Interprets the raw data stored in the <see cref="Data"/> property as a literal. /// </summary> /// <param name="elementType">The type of the literal.</param> /// <returns>The deserialized literal.</returns> public object InterpretData(ElementType elementType) { var reader = ByteArrayDataSource.CreateReader(Data); return(elementType switch { ElementType.Boolean => (object)(reader.ReadByte() != 0), ElementType.Char => (char)reader.ReadUInt16(), ElementType.I1 => reader.ReadSByte(), ElementType.U1 => reader.ReadByte(), ElementType.I2 => reader.ReadInt16(), ElementType.U2 => reader.ReadUInt16(), ElementType.I4 => reader.ReadInt32(), ElementType.U4 => reader.ReadUInt32(), ElementType.I8 => reader.ReadInt64(), ElementType.U8 => reader.ReadUInt64(), ElementType.R4 => reader.ReadSingle(), ElementType.R8 => reader.ReadDouble(), ElementType.String => Encoding.Unicode.GetString(reader.ReadToEnd()), _ => throw new ArgumentOutOfRangeException(nameof(elementType)) });
public void PersistentStringFileInfo() { // Prepare mock data. var versionInfo = new VersionInfoResource(); var stringFileInfo = new StringFileInfo(); var table = new StringTable(0, 0x4b0) { [StringTable.ProductNameKey] = "Sample product", [StringTable.FileVersionKey] = "1.2.3.4", [StringTable.ProductVersionKey] = "1.0.0.0", [StringTable.FileDescriptionKey] = "This is a sample description" }; stringFileInfo.Tables.Add(table); versionInfo.AddEntry(stringFileInfo); // Serialize. var tempStream = new MemoryStream(); versionInfo.Write(new BinaryStreamWriter(tempStream)); // Reload. var infoReader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newVersionInfo = VersionInfoResource.FromReader(ref infoReader); // Verify. var newStringFileInfo = newVersionInfo.GetChild <StringFileInfo>(StringFileInfo.StringFileInfoKey); Assert.NotNull(newStringFileInfo); Assert.Single(newStringFileInfo.Tables); var newTable = newStringFileInfo.Tables[0]; foreach ((string key, string value) in table) { Assert.Equal(value, newTable[key]); } }
public void PersistentFixedVersionInfo() { // Prepare mock data. var versionInfo = new VersionInfoResource(); var fixedVersionInfo = new FixedVersionInfo { FileVersion = new System.Version(1, 2, 3, 4), ProductVersion = new System.Version(1, 2, 3, 4), FileDate = 0x12345678_9ABCDEF, FileFlags = FileFlags.SpecialBuild, FileFlagsMask = FileFlags.ValidBitMask, FileType = FileType.App, FileOS = FileOS.NT, FileSubType = FileSubType.DriverInstallable, }; versionInfo.FixedVersionInfo = fixedVersionInfo; // Serialize. var tempStream = new MemoryStream(); versionInfo.Write(new BinaryStreamWriter(tempStream)); // Reload. var infoReader = ByteArrayDataSource.CreateReader(tempStream.ToArray()); var newVersionInfo = VersionInfoResource.FromReader(ref infoReader); var newFixedVersionInfo = newVersionInfo.FixedVersionInfo; // Verify. Assert.Equal(fixedVersionInfo.FileVersion, newFixedVersionInfo.FileVersion); Assert.Equal(fixedVersionInfo.ProductVersion, newFixedVersionInfo.ProductVersion); Assert.Equal(fixedVersionInfo.FileDate, newFixedVersionInfo.FileDate); Assert.Equal(fixedVersionInfo.FileFlags, newFixedVersionInfo.FileFlags); Assert.Equal(fixedVersionInfo.FileFlagsMask, newFixedVersionInfo.FileFlagsMask); Assert.Equal(fixedVersionInfo.FileType, newFixedVersionInfo.FileType); Assert.Equal(fixedVersionInfo.FileOS, newFixedVersionInfo.FileOS); Assert.Equal(fixedVersionInfo.FileSubType, newFixedVersionInfo.FileSubType); }
public void PersistentResources() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Add new directory. const string directoryName = "Test"; var entryData = new byte[] { 0, 1, 2, 3, 4 }; var directory = new ResourceDirectory(directoryName) { Entries = { new ResourceDirectory(1) { Entries ={ new ResourceData(1234, new DataSegment(entryData)) } } } }; module.NativeResourceDirectory.Entries.Add(directory); // Write and rebuild. using var stream = new MemoryStream(); module.Write(stream); var newModule = ModuleDefinition.FromReader(ByteArrayDataSource.CreateReader(stream.ToArray())); // Assert contents. var newDirectory = (IResourceDirectory)newModule.NativeResourceDirectory.Entries .First(entry => entry.Name == directoryName); newDirectory = (IResourceDirectory)newDirectory.Entries[0]; var newData = (IResourceData)newDirectory.Entries[0]; var newContents = (IReadableSegment)newData.Contents; Assert.Equal(entryData, newContents.ToArray()); }
private static AssemblyDefinition Rebuild(AssemblyDefinition assembly) { using var stream = new MemoryStream(); assembly.ManifestModule.Write(stream); return(AssemblyDefinition.FromReader(ByteArrayDataSource.CreateReader(stream.ToArray()))); }
/// <inheritdoc /> public override object ResolveMember(MetadataToken token) { switch (token.Table) { case TableIndex.TypeDef: var type = _tokens[(int)token.Rid]; if (type is RuntimeTypeHandle runtimeTypeHandle) { return(_importer.ImportType(Type.GetTypeFromHandle(runtimeTypeHandle))); } break; case TableIndex.Field: var field = _tokens[(int)token.Rid]; if (field is null) { return(null); } if (field is RuntimeFieldHandle runtimeFieldHandle) { return(_importer.ImportField(FieldInfo.GetFieldFromHandle(runtimeFieldHandle))); } if (field.GetType().FullName == "System.Reflection.Emit.GenericFieldInfo") { bool result = FieldReader.TryReadField <RuntimeFieldHandle>(field, "m_field", out var mField); var ctx = FieldReader.ReadField <RuntimeTypeHandle>(field, "m_context"); return(_importer.ImportField(FieldInfo.GetFieldFromHandle(result ? mField : FieldReader.ReadField <RuntimeFieldHandle>(field, "m_fieldHandle"), ctx))); } break; case TableIndex.Method: case TableIndex.MemberRef: var obj = _tokens[(int)token.Rid]; if (obj is RuntimeMethodHandle methodHandle) { return(_importer.ImportMethod(MethodBase.GetMethodFromHandle(methodHandle))); } if (obj.GetType().FullName == "System.Reflection.Emit.GenericMethodInfo") { var context = FieldReader.ReadField <RuntimeTypeHandle>(obj, "m_context"); bool hasHandle = FieldReader.TryReadField <RuntimeMethodHandle>(obj, "m_method", out var mMethod); var mHandle = FieldReader.ReadField <RuntimeMethodHandle>(obj, "m_methodHandle"); var method = MethodBase.GetMethodFromHandle( hasHandle ? mMethod : mHandle, context); return(_importer.ImportMethod(method)); } if (obj.GetType().FullName == "System.Reflection.Emit.VarArgMethod") { return(_importer.ImportMethod(FieldReader.ReadField <MethodInfo>(obj, "m_method"))); } break; case TableIndex.StandAloneSig: var reader = ByteArrayDataSource.CreateReader((byte[])_tokens[(int)token.Rid]); return(CallingConventionSignature.FromReader(new BlobReadContext(_readerContext), ref reader)); } return(token); }
/// <summary> /// Reads a private key from an input file. /// </summary> /// <param name="path">The path to the strong-name key file.</param> /// <returns>The private key.</returns> /// <exception cref="FormatException">Occurs when the input stream is not in the correct format.</exception> /// <exception cref="NotSupportedException">Occurs when an invalid or unsupported algorithm is specified.</exception> public static StrongNamePublicKey FromFile(string path) { var reader = ByteArrayDataSource.CreateReader(System.IO.File.ReadAllBytes(path)); return(FromReader(ref reader)); }
private static ModuleDefinition Rebuild(ModuleDefinition module) { using var stream = new MemoryStream(); module.Write(stream); return(ModuleDefinition.FromReader(ByteArrayDataSource.CreateReader(stream.ToArray()))); }
/// <summary> /// Creates a new tables stream based on a byte array. /// </summary> /// <param name="context">The reader context.</param> /// <param name="name">The name of the stream.</param> /// <param name="rawData">The raw contents of the stream.</param> public SerializedTableStream(PEReaderContext context, string name, byte[] rawData) : this(context, name, ByteArrayDataSource.CreateReader(rawData)) { }
/// <summary> /// Creates a new GUID stream based on a byte array. /// </summary> /// <param name="name">The name of the stream.</param> /// <param name="rawData">The raw contents of the stream.</param> public SerializedGuidStream(string name, byte[] rawData) : this(name, ByteArrayDataSource.CreateReader(rawData)) { }