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);
}
