public void ReadManifestModule() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); Assert.NotNull(module.Assembly); Assert.Same(module, module.Assembly.ManifestModule); }
public void ResolveCorLibTypeSignature() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var definition = _fwResolver.ResolveType(module.CorLibTypeFactory.Object); Assert.Equal(module.CorLibTypeFactory.Object.Type, definition, _comparer); }
public void CloneHelloWorldProgramType() { var sourceModule = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var targetModule = PrepareTempModule(); var programType = sourceModule.TopLevelTypes.First(t => t.Name == "Program"); var nestedType = new TypeDefinition("", "Nested", PE.DotNet.Metadata.Tables.Rows.TypeAttributes.NestedPublic); programType.NestedTypes.Add(nestedType); var notNestedType = new TypeDefinition("", "NotNested", PE.DotNet.Metadata.Tables.Rows.TypeAttributes.Public); sourceModule.TopLevelTypes.Add(notNestedType); var result = new MemberCloner(targetModule) .Include(programType, notNestedType) .Clone(); Assert.Contains(nestedType, result.OriginalMembers); Assert.Contains(result.GetClonedMember(nestedType), result.ClonedMembers); Assert.DoesNotContain(result.GetClonedMember(nestedType), result.ClonedTopLevelTypes); Assert.Contains(result.GetClonedMember(notNestedType), result.ClonedTopLevelTypes); Assert.Contains(result.GetClonedMember(programType), result.ClonedTopLevelTypes); foreach (var type in result.ClonedTopLevelTypes) { targetModule.TopLevelTypes.Add(type); } targetModule.ManagedEntrypointMethod = (MethodDefinition)result.ClonedMembers.First(m => m.Name == "Main"); _fixture .GetRunner <FrameworkPERunner>() .RebuildAndRun(targetModule, "HelloWorld.exe", "Hello World!" + Environment.NewLine); }
public void ReadVersion() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var assemblyRef = module.AssemblyReferences[0]; Assert.Equal(new Version(4, 0, 0, 0), assemblyRef.Version); }
public void RebuildWithPreserveAbsentUSStream() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_NoUSStream); var image = module.ToPEImage(new ManagedPEImageBuilder(MetadataBuilderFlags.PreserveUserStringIndices)); Assert.Null(image.DotNetDirectory.Metadata.GetStream <UserStringsStream>()); }
public void HelloWorldReadAssemblyReferences() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); Assert.Single(module.AssemblyReferences); Assert.Equal("mscorlib", module.AssemblyReferences[0].Name); }
public void NewFieldDefinition() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Create new field. var field = new FieldDefinition( "MyField", FieldAttributes.Public | FieldAttributes.Static, FieldSignature.CreateStatic(module.CorLibTypeFactory.Object)); module.GetOrCreateModuleType().Fields.Add(field); // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid token. var newToken = result.TokenMapping[field]; Assert.NotEqual(0u, newToken.Rid); // Assert token resolves to the new field. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newField = (FieldDefinition)newModule.LookupMember(newToken); Assert.Equal(field.Name, newField.Name); }
public void NewMethodDefinition() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Create new method. var method = new MethodDefinition( "MyMethod", MethodAttributes.Public | MethodAttributes.Static, MethodSignature.CreateStatic(module.CorLibTypeFactory.Void)); module.GetOrCreateModuleType().Methods.Add(method); // Get existing main method. var main = module.ManagedEntrypointMethod; // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid tokens for both methods. var methodToken = result.TokenMapping[method]; var mainMethodToken = result.TokenMapping[main]; Assert.NotEqual(0u, methodToken.Rid); Assert.NotEqual(0u, mainMethodToken.Rid); // Assert tokens resolve to the same methods. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newMethod = (MethodDefinition)newModule.LookupMember(methodToken); Assert.Equal(method.Name, newMethod.Name); var newMain = (MethodDefinition)newModule.LookupMember(mainMethodToken); Assert.Equal(main.Name, newMain.Name); }
public void NewMethodSpecification() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Import arbitrary generic method. var importer = new ReferenceImporter(module); var reference = importer.ImportMethod(typeof(Array).GetMethod("Empty").MakeGenericMethod(typeof(object))); // Ensure method reference is added to the module by referencing it in main. var instructions = module.ManagedEntrypointMethod.CilMethodBody.Instructions; instructions.Insert(0, CilOpCodes.Call, reference); instructions.Insert(1, CilOpCodes.Pop); // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid token. var newToken = result.TokenMapping[reference]; Assert.NotEqual(0u, newToken.Rid); // Assert token resolves to the same method reference. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newReference = (MethodSpecification)newModule.LookupMember(newToken); Assert.Equal(reference.Name, newReference.Name); }
public void NewStandaloneSignature() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Import arbitrary method signature. var importer = new ReferenceImporter(module); var signature = new StandAloneSignature( importer.ImportMethodSignature(MethodSignature.CreateStatic(module.CorLibTypeFactory.Void))); // Ensure reference is added to the module by referencing it in main. var instructions = module.ManagedEntrypointMethod.CilMethodBody.Instructions; instructions.Insert(0, CilOpCodes.Ldnull); instructions.Insert(0, CilOpCodes.Calli, signature); // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid token. var newToken = result.TokenMapping[signature]; Assert.NotEqual(0u, newToken.Rid); // Assert token resolves to the same method reference. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newSignature = (StandAloneSignature)newModule.LookupMember(newToken); Assert.Equal(signature.Signature, newSignature.Signature, new SignatureComparer()); }
public void NewTypeReference() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Import arbitrary type as reference. var importer = new ReferenceImporter(module); var reference = importer.ImportType(typeof(MemoryStream)); // Ensure type ref is added to the module by adding a dummy field referencing it. module.GetOrCreateModuleType().Fields.Add(new FieldDefinition( "MyField", FieldAttributes.Public | FieldAttributes.Static, FieldSignature.CreateStatic(reference.ToTypeSignature()))); // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid token. var newToken = result.TokenMapping[reference]; Assert.NotEqual(0u, newToken.Rid); // Assert token resolves to the same type reference. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newReference = (TypeReference)newModule.LookupMember(newToken); Assert.Equal(reference.Namespace, newReference.Namespace); Assert.Equal(reference.Name, newReference.Name); }
public void NewTypeDefinition() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); // Create new type. var type = new TypeDefinition("Namespace", "Name", TypeAttributes.Interface);; module.TopLevelTypes.Add(type); // Rebuild. var builder = new ManagedPEImageBuilder(); var result = builder.CreateImage(module); // Assert valid token. var newToken = result.TokenMapping[type]; Assert.NotEqual(0u, newToken.Rid); // Assert token resolves to the new type. var newModule = ModuleDefinition.FromImage(result.ConstructedImage); var newType = (TypeDefinition)newModule.LookupMember(newToken); Assert.Equal(type.Namespace, newType.Namespace); Assert.Equal(type.Name, newType.Name); }
public void MaliciousTypeSpecLoop() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_MaliciousTypeSpecLoop); var typeSpec = (TypeSpecification)module.LookupMember(new MetadataToken(TableIndex.TypeSpec, 1)); Assert.NotNull(typeSpec); }
public void IllegalTypeSpecInTypeDefOrRef() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_IllegalTypeSpecInTypeDefOrRefSig); var typeSpec = (TypeSpecification)module.LookupMember(new MetadataToken(TableIndex.TypeSpec, 1)); Assert.NotNull(typeSpec); }
public void ReadName() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var assemblyRef = module.AssemblyReferences[0]; Assert.Equal("mscorlib", assemblyRef.Name); }
public void ReadAssemblyRefScope() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var typeRef = (TypeReference)module.LookupMember(new MetadataToken(TableIndex.TypeRef, 13)); Assert.Equal("mscorlib", typeRef.Scope.Name); }
public void MaliciousExportedTypeLoop() { // Load assemblies. var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_MaliciousExportedTypeLoop); var assembly1 = AssemblyDefinition.FromBytes(Properties.Resources.Assembly1_MaliciousExportedTypeLoop); var assembly2 = AssemblyDefinition.FromBytes(Properties.Resources.Assembly2_MaliciousExportedTypeLoop); // Manually wire assemblies together for in-memory resolution. var resolver = (AssemblyResolverBase)module.MetadataResolver.AssemblyResolver; resolver.AddToCache(assembly1, assembly1); resolver.AddToCache(assembly2, assembly2); resolver = (AssemblyResolverBase)assembly1.ManifestModule.MetadataResolver.AssemblyResolver; resolver.AddToCache(assembly1, assembly1); resolver.AddToCache(assembly2, assembly2); resolver = (AssemblyResolverBase)assembly2.ManifestModule.MetadataResolver.AssemblyResolver; resolver.AddToCache(assembly1, assembly1); resolver.AddToCache(assembly2, assembly2); // Find reference to exported type loop. var reference = module .GetImportedTypeReferences() .First(t => t.Name == "SomeName"); // Attempt to resolve. The test here is that it should not result in an infinite loop / stack overflow. Assert.Null(reference.Resolve()); }
public void PreserveTypeDefsRemoveTypeShouldStuffTypeDefSlots() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_NetCore); for (int i = 0; i < 10; i++) { module.TopLevelTypes.Add(new TypeDefinition("Namespace", $"Type{i.ToString()}", TypeAttributes.Public)); } module = RebuildAndReloadModule(module, MetadataBuilderFlags.None); const int indexToRemove = 2; var originalTypeDefs = GetMembers <TypeDefinition>(module, TableIndex.TypeDef); module.TopLevelTypes.RemoveAt(indexToRemove); var newModule = RebuildAndReloadModule(module, MetadataBuilderFlags.PreserveTypeDefinitionIndices); var newTypeDefs = GetMembers <TypeDefinition>(newModule, TableIndex.TypeDef); for (int i = 0; i < originalTypeDefs.Count; i++) { if (i != indexToRemove) { Assert.Equal(originalTypeDefs[i], newTypeDefs[i], Comparer); } } }
public void ReadName() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); Assert.Equal("<Module>", module.TopLevelTypes[0].Name); Assert.Equal("Program", module.TopLevelTypes[1].Name); }
public void ReadNamespace() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); Assert.Null(module.TopLevelTypes[0].Namespace); Assert.Equal("HelloWorld", module.TopLevelTypes[1].Namespace); }
private static NativeMethodBody CreateDummyBody(bool isVoid, bool is32Bit) { var module = ModuleDefinition.FromBytes(Properties.Resources.TheAnswer_NetFx); module.Attributes &= DotNetDirectoryFlags.ILOnly; if (is32Bit) { module.PEKind = OptionalHeaderMagic.Pe32; module.MachineType = MachineType.I386; module.Attributes |= DotNetDirectoryFlags.Bit32Required; } else { module.PEKind = OptionalHeaderMagic.Pe32Plus; module.MachineType = MachineType.Amd64; } var method = module .TopLevelTypes.First(t => t.Name == "Program") .Methods.First(m => m.Name == "GetTheAnswer"); method.Attributes |= MethodAttributes.PInvokeImpl; method.ImplAttributes |= MethodImplAttributes.Unmanaged | MethodImplAttributes.Native | MethodImplAttributes.PreserveSig; method.DeclaringType.Methods.Remove(method); module.GetOrCreateModuleType().Methods.Add(method); return(method.NativeMethodBody = new NativeMethodBody(method)); }
private static ModuleDefinition CreateSampleEventDefsModule(int typeCount, int EventsPerType) { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_NetCore); var eventHandlerTypeRef = new TypeReference( module, module.CorLibTypeFactory.CorLibScope, "System", nameof(EventHandler)); for (int i = 0; i < typeCount; i++) { var dummyType = new TypeDefinition("Namespace", $"Type{i.ToString()}", TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed); module.TopLevelTypes.Add(dummyType); for (int j = 0; j < EventsPerType; j++) { dummyType.Events.Add(CreateDummyEventToType( dummyType, eventHandlerTypeRef, $"Event_{j.ToString()}")); } } return(RebuildAndReloadModule(module, MetadataBuilderFlags.None)); }
public void ExceptionHandlerWithHandlerEndOutsideOfMethodShouldResultInEndLabel() { var module = ModuleDefinition.FromBytes(Properties.Resources.HandlerEndAtEndOfMethodBody); var body = module.ManagedEntrypointMethod.CilMethodBody; Assert.Same(body.Instructions.EndLabel, body.ExceptionHandlers[0].HandlerEnd); }
public void MaliciousTypeSpecLoop() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_MaliciousTypeSpecLoop, new ModuleReaderParameters(EmptyErrorListener.Instance)); var typeSpec = (TypeSpecification)module.LookupMember(new MetadataToken(TableIndex.TypeSpec, 1)); Assert.NotNull(typeSpec.Signature); }
public void ReadBaseType() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); Assert.Null(module.TopLevelTypes[0].BaseType); Assert.NotNull(module.TopLevelTypes[1].BaseType); Assert.Equal("System.Object", module.TopLevelTypes[1].BaseType.FullName); }
public void ResolveSystemObjectNetCore() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_NetCore); var reference = new TypeReference(module.CorLibTypeFactory.CorLibScope, "System", "Object"); var definition = _coreResolver.ResolveType(reference); Assert.True(definition.IsTypeOf(reference.Namespace, reference.Name)); }
public void ResolveSystemObjectFramework() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); var reference = new TypeReference(module.CorLibTypeFactory.CorLibScope, "System", "Object"); var definition = _fwResolver.ResolveType(reference); Assert.Equal((ITypeDefOrRef)reference, definition, _comparer); }
public void LinkedToModule() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld); foreach (var type in module.TopLevelTypes) { Assert.Same(module, type.Module); } }
private TypeDefinition RebuildAndLookup(TypeDefinition type) { var stream = new MemoryStream(); type.Module.Write(stream); var newModule = ModuleDefinition.FromBytes(stream.ToArray()); return(newModule.TopLevelTypes.FirstOrDefault(t => t.FullName == type.FullName)); }
public void PreserveAssemblyRefsNoChangeShouldAtLeastHaveOriginalAssemblyRefs() { var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld_NetCore); var originalAssemblyRefs = GetMembers <AssemblyReference>(module, TableIndex.AssemblyRef); var newModule = RebuildAndReloadModule(module, MetadataBuilderFlags.PreserveAssemblyReferenceIndices); var newAssemblyRefs = GetMembers <AssemblyReference>(newModule, TableIndex.AssemblyRef); Assert.Equal(originalAssemblyRefs, newAssemblyRefs.Take(originalAssemblyRefs.Count), Comparer); }