public void ComplexGenericTypeInstance()
{
var spec = CreateDummyType();
var image = spec.Image;
var importer = new ReferenceImporter(image);
// Tuple<Tuple<decimal, decimal>, Tuple<decimal, decimal>>
var signature =
new GenericInstanceTypeSignature(importer.ImportType(typeof(Tuple <,>)),
new GenericInstanceTypeSignature(
importer.ImportType(typeof(Tuple <,>)),
importer.ImportTypeSignature(typeof(decimal)),
importer.ImportTypeSignature(typeof(decimal))),
new GenericInstanceTypeSignature(
importer.ImportType(typeof(Tuple <,>)),
importer.ImportTypeSignature(typeof(decimal)),
importer.ImportTypeSignature(typeof(decimal))));
spec.Signature = signature;
var header = image.Header;
var mapping = header.UnlockMetadata();
var newImage = header.LockMetadata();
var newSpec = (TypeSpecification)newImage.ResolveMember(mapping[spec]);
Assert.Equal(signature, newSpec.Signature, Comparer);
}
public void PersistentTypeArgument()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var header = assembly.NetDirectory.MetadataHeader;
var image = header.LockMetadata();
var importer = new ReferenceImporter(image);
var argument = importer.ImportTypeSignature(typeof(object));
var customAttribute = new CustomAttribute(
(ICustomAttributeType)importer.ImportMethod(
typeof(DesignerAttribute).GetConstructor(new[] { typeof(Type) })),
new CustomAttributeSignature(new[]
{
new CustomAttributeArgument(importer.ImportTypeSignature(typeof(Type)),
new ElementSignature(argument))
}));
image.Assembly.CustomAttributes.Add(customAttribute);
header.UnlockMetadata();
image = header.LockMetadata();
Assert.Single(image.Assembly.CustomAttributes);
Assert.Equal(argument, image.Assembly.CustomAttributes[0].Signature.FixedArguments[0].Elements[0].Value as ITypeDescriptor, _comparer);
}
public void CreateGenericInstanceFieldReflection()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var fieldTable = tableStream.GetTable <FieldDefinition>();
var importer = new ReferenceImporter(tableStream);
// create field.
var typeSignature = (GenericInstanceTypeSignature)importer.ImportTypeSignature(typeof(List <string>));
var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static,
new FieldSignature(typeSignature));
fieldTable.Add(field);
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly);
fieldTable = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>().GetTable <FieldDefinition>();
field = fieldTable.First(x => x.Name == FieldName);
Assert.IsInstanceOfType(field.Signature.FieldType, typeof(GenericInstanceTypeSignature));
var newTypeSignature = (GenericInstanceTypeSignature)field.Signature.FieldType;
Utilities.ValidateType(typeSignature.GenericType, newTypeSignature.GenericType);
Assert.AreEqual(typeSignature.GenericArguments.Count, newTypeSignature.GenericArguments.Count);
for (int i = 0; i < typeSignature.GenericArguments.Count; i++)
{
Assert.AreEqual(typeSignature.GenericArguments[i].FullName,
newTypeSignature.GenericArguments[i].FullName);
}
}
public void ImportGenericInstanceType()
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var signature = new GenericInstanceTypeSignature(CreateTypeReference(typeof(List <>)));
var genericArg = CreateTypeDefOrRef(typeof(Form));
signature.GenericArguments.Add(genericArg);
var newSignature = importer.ImportTypeSignature(signature);
Assert.AreNotSame(signature, newSignature,
"Imported signature is the same object as original.");
Assert.IsTrue(_comparer.MatchTypes(signature, newSignature),
"Imported signature does not match original.");
Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, signature.GenericType)) != null,
"Generic type reference not added to table.");
Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, genericArg.Type)) != null,
"Generic type argument not added to table.");
}
public void PersistentVariables()
{
var methodBody = CreateDummyMethodBody();
var image = methodBody.Method.Image;
var importer = new ReferenceImporter(image);
var var1 = new VariableSignature(image.TypeSystem.Int32);
var var2 = new VariableSignature(importer.ImportTypeSignature(typeof(Stream)));
methodBody.Signature = new StandAloneSignature(new LocalVariableSignature(new[] { var1, var2 }));
var mapping = image.Header.UnlockMetadata();
image = image.Header.LockMetadata();
methodBody = ((MethodDefinition)image.ResolveMember(mapping[methodBody.Method])).CilMethodBody;
Assert.NotNull(methodBody.Signature);
Assert.IsType <LocalVariableSignature>(methodBody.Signature.Signature);
var localVarSig = (LocalVariableSignature)methodBody.Signature.Signature;
Assert.Equal(2, localVarSig.Variables.Count);
Assert.Equal(var1.VariableType, localVarSig.Variables[0].VariableType, _comparer);
Assert.Equal(var2.VariableType, localVarSig.Variables[1].VariableType, _comparer);
}
public void PersistentEnumArgument()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var header = assembly.NetDirectory.MetadataHeader;
var image = header.LockMetadata();
var importer = new ReferenceImporter(image);
const int argument = (int)DebuggableAttribute.DebuggingModes.EnableEditAndContinue;
var customAttribute = new CustomAttribute(
(ICustomAttributeType)importer.ImportMethod(
typeof(DebuggableAttribute).GetConstructor(new[] { typeof(DebuggableAttribute.DebuggingModes) })),
new CustomAttributeSignature(new[]
{
new CustomAttributeArgument(importer.ImportTypeSignature(typeof(DebuggableAttribute.DebuggingModes)),
new ElementSignature(argument))
}));
image.Assembly.CustomAttributes.Add(customAttribute);
header.UnlockMetadata();
image = header.LockMetadata();
Assert.Single(image.Assembly.CustomAttributes);
Assert.Equal(argument, image.Assembly.CustomAttributes[0].Signature.FixedArguments[0].Elements[0].Value);
}
public void ImportGenericInstanceType()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var signature = new GenericInstanceTypeSignature(CreateTypeReference(typeof(List <>)));
var genericArg = CreateTypeDefOrRef(typeof(Form));
signature.GenericArguments.Add(genericArg);
var newSignature = importer.ImportTypeSignature(signature);
Assert.NotSame(signature, newSignature);
Assert.Equal(signature, newSignature, _comparer);
var newGenericSiganture = (GenericInstanceTypeSignature)newSignature;
Assert.Equal(image, newGenericSiganture.GenericType.Image);
var genericArgElementType = newGenericSiganture.GenericArguments[0].GetElementType();
Assert.IsAssignableFrom <ITypeDefOrRef>(genericArgElementType);
Assert.Equal(image, ((ITypeDefOrRef)genericArgElementType).Image);
}
public void CreateArrayField()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem;
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var fieldTable = tableStream.GetTable <FieldDefinition>();
var importer = new ReferenceImporter(tableStream);
// create field.
var arraySignature = new ArrayTypeSignature(typeSystem.Int32);
arraySignature.Dimensions.Add(new ArrayDimension(2, 1));
arraySignature.Dimensions.Add(new ArrayDimension(2));
arraySignature.Dimensions.Add(new ArrayDimension());
var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static,
new FieldSignature(importer.ImportTypeSignature(arraySignature)));
fieldTable.Add(field);
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly);
fieldTable = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>().GetTable <FieldDefinition>();
field = fieldTable.First(x => x.Name == FieldName);
Assert.IsInstanceOfType(field.Signature.FieldType, typeof(ArrayTypeSignature));
Utilities.ValidateType(arraySignature, field.Signature.FieldType);
}
public void ResolveMethodGenericParameterWithMethod()
{
var genericInstance = new GenericInstanceMethodSignature();
genericInstance.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string)));
var context = new GenericContext(null, genericInstance);
var parameter = new GenericParameterSignature(GenericParameterType.Method, 0);
Assert.Equal("System.String", context.GetTypeArgument(parameter).FullName);
}
public void ImportCorlibType()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var signature = image.TypeSystem.Byte;
var newSignature = importer.ImportTypeSignature(signature);
Assert.Same(signature, newSignature);
}
public void ImportCorlibType()
{
var assembly = Utilities.CreateTempNetAssembly();
var metadataHeader = assembly.NetDirectory.MetadataHeader;
var tableStream = metadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var signature = metadataHeader.TypeSystem.Byte;
var newSignature = importer.ImportTypeSignature(signature);
Assert.AreSame(signature, newSignature,
"Imported signature is not the same object as original.");
}
public void ImportTypeDefOrRefSignature()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var signature = CreateTypeDefOrRef(typeof(Form));
var newSignature = importer.ImportTypeSignature(signature);
Assert.NotSame(signature, newSignature);
Assert.Equal(signature, newSignature, _comparer);
}
public void CreateAttributeWithEnumArgument()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var assemblyTable = tableStream.GetTable <AssemblyDefinition>();
var attributeTable = tableStream.GetTable <CustomAttribute>();
var importer = new ReferenceImporter(tableStream);
var assemblyDef = assemblyTable[0];
// create custom attribute.
var signature = new CustomAttributeSignature();
signature.FixedArguments.Add(
new CustomAttributeArgument(importer.ImportTypeSignature(typeof(DebuggableAttribute.DebuggingModes)),
new ElementSignature((int)DebuggableAttribute.DebuggingModes.Default)));
var attribute = new CustomAttribute(importer.ImportMember(typeof(DebuggableAttribute).GetConstructor(new Type[]
{
typeof(DebuggableAttribute.DebuggingModes)
})), signature);
assemblyDef.CustomAttributes.Add(attribute);
attributeTable.Add(attribute);
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly);
tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
assemblyTable = tableStream.GetTable <AssemblyDefinition>();
assemblyDef = assemblyTable[0];
attributeTable = tableStream.GetTable <CustomAttribute>();
var newAttribute = attributeTable[0];
Assert.IsTrue(assemblyDef.CustomAttributes.Contains(newAttribute));
Assert.AreEqual(attribute.Constructor.FullName, newAttribute.Constructor.FullName);
Assert.AreEqual(attribute.Signature.FixedArguments.Count, newAttribute.Signature.FixedArguments.Count);
for (int i = 0; i < attribute.Signature.FixedArguments.Count; i++)
{
Utilities.ValidateArgument(attribute.Signature.FixedArguments[i], newAttribute.Signature.FixedArguments[i]);
}
}
public void OperandTypeMethod()
{
var methodBody = CreateDummyMethodBody();
var image = methodBody.Method.Image;
var importer = new ReferenceImporter(image);
var instructions = methodBody.Instructions;
var simpleMethod = importer.ImportMethod(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }));
var genericInstanceMethod = new MethodSpecification(
new MemberReference(
importer.ImportType(typeof(Activator)),
"CreateInstance",
new MethodSignature(new GenericParameterSignature(GenericParameterType.Method, 0))
{
GenericParameterCount = 1,
IsGeneric = true
}),
new GenericInstanceMethodSignature(importer.ImportTypeSignature(typeof(Stream))));
instructions.AddRange(new[]
{
CilInstruction.Create(CilOpCodes.Ldstr, "Some String"),
CilInstruction.Create(CilOpCodes.Call, simpleMethod),
CilInstruction.Create(CilOpCodes.Call, importer.ImportMethod(genericInstanceMethod)),
CilInstruction.Create(CilOpCodes.Pop),
CilInstruction.Create(CilOpCodes.Ret)
});
var mapping = image.Header.UnlockMetadata();
image = image.Header.LockMetadata();
var newMethod = (MethodDefinition)image.ResolveMember(mapping[methodBody.Method]);
instructions = newMethod.CilMethodBody.Instructions;
Assert.Equal(simpleMethod, instructions[1].Operand as IMemberReference, _comparer);
Assert.Equal(genericInstanceMethod, instructions[2].Operand as IMemberReference, _comparer);
}
private TSignature TestTypeSpecification <TSignature>(TSignature signature, ITypeDefOrRef baseType)
where TSignature : TypeSpecificationSignature
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var newSignature = importer.ImportTypeSignature(signature);
Assert.IsType <TSignature>(newSignature);
Assert.NotSame(signature, newSignature);
Assert.Equal(signature, newSignature, _comparer);
var elementType = newSignature.GetElementType();
Assert.IsAssignableFrom <ITypeDefOrRef>(elementType);
Assert.Equal(baseType, elementType, _comparer);
Assert.Equal(image, ((ITypeDefOrRef)elementType).Image);
return((TSignature)newSignature);
}
public void MaliciousMetadataLoop2()
{
var spec = CreateDummyType();
var image = spec.Image;
var importer = new ReferenceImporter(image);
spec.Signature =
new GenericInstanceTypeSignature(importer.ImportType(typeof(Tuple <,>)),
new MaliciousTypeSignature(
importer.ImportType(typeof(object)),
spec),
importer.ImportTypeSignature(typeof(decimal)));
var header = image.Header;
var mapping = header.UnlockMetadata();
var newImage = header.LockMetadata();
var newSpec = (TypeSpecification)newImage.ResolveMember(mapping[spec]);
Assert.NotEqual(spec.Signature, newSpec.Signature, Comparer);
}
private static TSignature TestTypeSpecification <TSignature>(TSignature signature, ITypeDefOrRef baseType)
where TSignature : TypeSpecificationSignature
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var newSignature = importer.ImportTypeSignature(signature);
Assert.IsInstanceOfType(newSignature, typeof(TSignature));
Assert.AreNotSame(signature, newSignature,
"Imported signature is the same object as original.");
Assert.IsTrue(_comparer.MatchTypes(signature, newSignature),
"Imported signature does not match original.");
Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, baseType)) != null,
"Base type reference not added to table.");
return((TSignature)newSignature);
}
/// <summary>
/// Do Proxy Signature.
/// </summary>
/// <param name="IsNewobj"> Ditermine If The Processed Instruction Is CilOpCodes.NewObj. </param>
/// <param name="Method"> Method to Call. </param>
/// <returns> Proxy Method Sig. </returns>
private static MethodSignature GetSignature(bool IsNewobj, IMethodDescriptor Method)
{
// Get Return Type.
var _returntype = IsNewobj
? Method.DeclaringType.ToTypeSignature()
: Method.Signature.ReturnType;
// Assign Params Type.
IList <TypeSignature> _params = new List <TypeSignature>();
/// Inserting TypeSigs From <param name="Method"/> Sig.
foreach (var _tsig in Method.Signature.ParameterTypes)
{
_params.Add(_tsig);
}
// If Method Is HasThis Insert Object Sig.
if (Method.Signature.HasThis && !IsNewobj)
{
_params.Insert(0, _importer.ImportTypeSignature(Method.Resolve().Parameters.ThisParameter.ParameterType));
}
// Finally Return Maded Sig.
return(MethodSignature.CreateStatic(_returntype, _params));
}
public void CreateSimpleField()
{
var type = typeof(Process);
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var fieldTable = tableStream.GetTable <FieldDefinition>();
var importer = new ReferenceImporter(tableStream);
// create field.
var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static,
new FieldSignature(importer.ImportTypeSignature(type)));
fieldTable.Add(field);
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly);
fieldTable = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>().GetTable <FieldDefinition>();
field = fieldTable.First(x => x.Name == FieldName);
Utilities.ValidateType(type, field.Signature.FieldType);
}
private static WindowsAssembly CreateTempAssembly()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, false);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var type = new TypeDefinition(
TypeNamespace,
TypeName,
TypeAttributes.Public,
importer.ImportType(typeof(object)));
image.Assembly.Modules[0].TopLevelTypes.Add(type);
var mainMethod = new MethodDefinition(MainMethodName, MethodAttributes.Public | MethodAttributes.Static,
new MethodSignature(new[] { importer.ImportTypeSignature(typeof(string[])) },
image.TypeSystem.Void));
type.Methods.Add(mainMethod);
mainMethod.MethodBody = new CilMethodBody(mainMethod);
image.ManagedEntrypoint = mainMethod;
return(assembly);
}
