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