public static TypeDefinition ImportFlagHelper(ModuleDefinition module, VMConstants constants) { // Clone flag helper class. var cloner = new MemberCloner(module); cloner.Include(VmHelperType); var result = cloner.Clone(); var flagHelperType = result.ClonedMembers.OfType <TypeDefinition>().First(); module.Assembly.Modules[0].TopLevelTypes.Add(flagHelperType); // Obtain static cctor. var constructor = flagHelperType.Methods.First(x => x.IsConstructor && x.IsStatic); var instructions = constructor.CilMethodBody.Instructions; instructions.Clear(); // Assign values of flags to the fields. foreach (var entry in constants.Flags.OrderBy(x => x.Value)) { instructions.Add(CilInstruction.CreateLdcI4(entry.Key)); instructions.Add(new CilInstruction(CilOpCodes.Stsfld, flagHelperType.Fields.First(x => x.Name == "FL_" + entry.Value.ToString()))); } instructions.Add(new CilInstruction(CilOpCodes.Ret)); return(flagHelperType); }
public static TypeDefinition ImportFlagHelper(MetadataImage image, VMConstants constants) { // Clone flag helper class. var cloner = new MemberCloner(image); var flagHelperType = cloner.CloneType(VmHelperType); image.Assembly.Modules[0].TopLevelTypes.Add(flagHelperType); // Obtain static cctor. var constructor = flagHelperType.Methods.First(x => x.IsConstructor && x.IsStatic); var instructions = constructor.CilMethodBody.Instructions; instructions.Clear(); // Assign values of flags to the fields. foreach (var entry in constants.Flags.OrderBy(x => x.Value)) { instructions.Add(CilInstruction.Create(CilOpCodes.Ldc_I4, entry.Key)); instructions.Add(CilInstruction.Create(CilOpCodes.Stsfld, flagHelperType.Fields.First(x => x.Name == "FL_" + entry.Value.ToString()))); } instructions.Add(CilInstruction.Create(CilOpCodes.Ret)); return(flagHelperType); }
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 ExtensionMethodTest() { var sourceAssembly = WindowsAssembly.FromFile(typeof(StaticClass).Assembly.Location); var sourceImage = sourceAssembly.NetDirectory.MetadataHeader.LockMetadata(); var assembly = NetAssemblyFactory.CreateAssembly("SomeAssembly", false); var header = assembly.NetDirectory.MetadataHeader; var image = header.LockMetadata(); var importer = new ReferenceImporter(image); var cloner = new MemberCloner(image); var staticClass = sourceImage.Assembly.Modules[0].TopLevelTypes.First(x => x.Name == "StaticClass"); var clonedType = cloner.CloneType(staticClass); var main = new MethodDefinition("Main", MethodAttributes.Public | MethodAttributes.Static, new MethodSignature(image.TypeSystem.Void)); main.CilMethodBody = new CilMethodBody(main); var instructions = main.CilMethodBody.Instructions; instructions.Add(CilInstruction.Create(CilOpCodes.Ldc_I4_1)); instructions.Add(CilInstruction.Create(CilOpCodes.Call, clonedType.Methods.First(x => x.Name == "SomeExtension"))); instructions.Add(CilInstruction.Create(CilOpCodes.Call, importer.ImportMethod(typeof(Console).GetMethod("WriteLine", new[] { typeof(int) })))); instructions.Add(CilInstruction.Create(CilOpCodes.Ret)); image.Assembly.Modules[0].TopLevelTypes.Add(clonedType); image.Assembly.Modules[0].TopLevelTypes[0].Methods.Add(main); image.ManagedEntrypoint = main; header.UnlockMetadata(); _context.VerifyOutput(assembly, "4"); }
public void CloneParameterReferences() { var sourceAssembly = WindowsAssembly.FromFile(typeof(SimpleClass).Assembly.Location); var sourceImage = sourceAssembly.NetDirectory.MetadataHeader.LockMetadata(); var assembly = NetAssemblyFactory.CreateAssembly("SomeAssembly", false); var header = assembly.NetDirectory.MetadataHeader; var image = header.LockMetadata(); var cloner = new MemberCloner(image); var variablesClass = sourceImage.Assembly.Modules[0].TopLevelTypes.First(x => x.Name == "Variables"); var clonedClass = cloner.CloneType(variablesClass); image.Assembly.Modules[0].TopLevelTypes.Add(clonedClass); foreach (var clonedMethod in clonedClass.Methods.Where(x => x.CilMethodBody != null)) { var body = clonedMethod.CilMethodBody; var parameters = clonedMethod.Signature.Parameters; var originalBody = variablesClass.Methods.First(x => x.Name == clonedMethod.Name).CilMethodBody; var originalParameters = originalBody.Method.Signature.Parameters; foreach (var instruction in body.Instructions.Where(x => x.OpCode.OperandType == CilOperandType.InlineArgument || x.OpCode.OperandType == CilOperandType.ShortInlineArgument)) { var originalInstruction = originalBody.Instructions.GetByOffset(instruction.Offset); Assert.NotNull(instruction.Operand); Assert.Equal(originalParameters.IndexOf((ParameterSignature)originalInstruction.Operand), parameters.IndexOf((ParameterSignature)instruction.Operand)); } } }
private static MethodDefinition CloneMethod(MethodBase methodBase, out MethodDefinition originalMethodDef) { var sourceModule = ModuleDefinition.FromFile(methodBase.Module.Assembly.Location); originalMethodDef = (MethodDefinition)sourceModule.LookupMember(methodBase.MetadataToken); var targetModule = PrepareTempModule(); var result = new MemberCloner(targetModule) .Include(originalMethodDef) .Clone(); var clonedMethod = (MethodDefinition)result.ClonedMembers.First(); Assert.True(result.ContainsClonedMember(originalMethodDef)); Assert.Equal(clonedMethod, result.GetClonedMember(originalMethodDef)); return(clonedMethod); }
private static FieldDefinition CloneIntializerField(FieldInfo field, out FieldDefinition originalFieldDef) { var sourceModule = ModuleDefinition.FromFile(field.Module.Assembly.Location); originalFieldDef = (FieldDefinition)sourceModule.LookupMember(field.MetadataToken); originalFieldDef = originalFieldDef.FindInitializerField(); var targetModule = PrepareTempModule(); var result = new MemberCloner(targetModule) .Include(originalFieldDef) .Clone(); var clonedField = (FieldDefinition)result.ClonedMembers.First(); Assert.True(result.ContainsClonedMember(originalFieldDef)); Assert.Equal(clonedField, result.GetClonedMember(originalFieldDef)); return(clonedField); }
public void CircularReferenceTest() { var sourceAssembly = WindowsAssembly.FromFile(typeof(SimpleClass).Assembly.Location); var sourceImage = sourceAssembly.NetDirectory.MetadataHeader.LockMetadata(); var assembly = NetAssemblyFactory.CreateAssembly("SomeAssembly", false); var header = assembly.NetDirectory.MetadataHeader; var image = header.LockMetadata(); var cloner = new MemberCloner(image); var classA = sourceImage.Assembly.Modules[0].TopLevelTypes.First(x => x.Name == "ClassA"); var classB = sourceImage.Assembly.Modules[0].TopLevelTypes.First(x => x.Name == "ClassB"); var clonedTypes = cloner.CloneTypes(new[] { classA, classB }); foreach (var type in clonedTypes) { image.Assembly.Modules[0].TopLevelTypes.Add(type); } var main = new MethodDefinition("Main", MethodAttributes.Public | MethodAttributes.Static, new MethodSignature(image.TypeSystem.Void)); main.CilMethodBody = new CilMethodBody(main); main.CilMethodBody.Instructions.AddRange(new[] { CilInstruction.Create(CilOpCodes.Newobj, clonedTypes[0].Methods.First(x => x.Name == ".ctor")), CilInstruction.Create(CilOpCodes.Newobj, clonedTypes[1].Methods.First(x => x.Name == ".ctor")), CilInstruction.Create(CilOpCodes.Call, clonedTypes[0].Methods.First(x => x.Name == "Test")), CilInstruction.Create(CilOpCodes.Ret) }); image.Assembly.Modules[0].TopLevelTypes[0].Methods.Add(main); image.ManagedEntrypoint = main; header.UnlockMetadata(); _context.VerifyOutput(assembly, "MyPropertyA: MyPropertyB"); }
private static TypeDefinition CloneType(Type type, out TypeDefinition originalTypeDef) { var sourceModule = ModuleDefinition.FromFile(type.Module.Assembly.Location); originalTypeDef = (TypeDefinition)sourceModule.LookupMember(type.MetadataToken); var targetModule = PrepareTempModule(); var result = new MemberCloner(targetModule) .Include(originalTypeDef) .Clone(); var clonedType = result.ClonedMembers .OfType <TypeDefinition>() .First(); Assert.True(result.ContainsClonedMember(originalTypeDef)); Assert.Equal(clonedType, result.GetClonedMember(originalTypeDef)); Assert.Equal(clonedType, result.ClonedTopLevelTypes.First()); return(clonedType); }
protected static void InjectLoader(ModuleDefinition targetModule, Type loaderClass) { var sourceModule = ModuleDefinition.FromFile(typeof(Packer).Assembly.Location); var cloner = new MemberCloner(targetModule); var loader = (TypeDefinition)sourceModule.LookupMember(loaderClass.MetadataToken); cloner.Include(loader, true); var result = cloner.Clone(); foreach (var clonedType in result.ClonedTopLevelTypes) { targetModule.TopLevelTypes.Add(clonedType); } result.GetClonedMember(loader).Namespace = ""; var entryPoint = (MethodDefinition)result.ClonedMembers.First(m => m.Name == "Main"); entryPoint.Name = ".origami"; entryPoint.DeclaringType.Name = "<Origami>"; targetModule.ManagedEntrypoint = entryPoint; }
public void ReferenceToNestedClass() { var sourceModule = ModuleDefinition.FromFile(typeof(Miscellaneous).Assembly.Location); var type = sourceModule.TopLevelTypes.First(t => t.Name == nameof(Miscellaneous)); var targetModule = PrepareTempModule(); var result = new MemberCloner(targetModule) .Include(type.NestedTypes.First(t => t.Name == nameof(Miscellaneous.NestedClass))) .Include(type.Methods.First(m => m.Name == nameof(Miscellaneous.NestedClassLocal))) .Clone(); var clonedMethod = (MethodDefinition)result.ClonedMembers .First(m => m.Name == nameof(Miscellaneous.NestedClassLocal)); var references = clonedMethod.CilMethodBody.Instructions .Where(i => i.OpCode.Code == CilCode.Callvirt || i.OpCode.Code == CilCode.Newobj) .Select(i => i.Operand) .Cast <MethodDefinition>() .ToArray(); Assert.Equal(3, references.Length); Assert.All(references, method => Assert.Contains(result.ClonedMembers, descriptor => descriptor == method)); }