public void CheckDefault()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Var name='KeepPublicApi' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithNestedTypes2.dll'>" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes2", string.Empty, xml);
HashSet <string> typesToFind = new HashSet <string> ();
typesToFind.Add("TestClasses.ClassA");
typesToFind.Add("TestClasses.ClassA/A");
typesToFind.Add("TestClasses.ClassA/NestedClassB");
typesToFind.Add("TestClasses.ClassA/NestedClassB/NestedClassC");
AssemblyHelper.CheckAssembly("AssemblyWithNestedTypes2", 1,
delegate {
return(true);
},
delegate(TypeDefinition typeDef) {
Assert.IsTrue(typesToFind.Contains(typeDef.ToString()), "Type {0} not expected.", typeDef.ToString());
typesToFind.Remove(typeDef.ToString());
});
Assert.IsTrue(typesToFind.Count == 0, "Not all types found.");
}
public void CheckDropsProperties()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithProperties.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithProperties", string.Empty, xml);
string[] expected = new string[0];
string[] notExpected = new string[]
{
"Property1",
"Property2",
"PropertyA"
};
CheckProperties(Path.Combine(outputPath, "AssemblyWithProperties.dll"), 1, expected, notExpected);
}
public void CheckSkipEnum()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithTypes.dll'>" +
@"<SkipType name='TestClasses.TestEnum' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
Obfuscar.Obfuscator obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml);
var map = obfuscator.Mapping;
string assmName = "AssemblyWithTypes.dll";
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, assmName));
var enumType = inAssmDef.MainModule.GetType("TestClasses.TestEnum");
var enum1 = map.GetClass(new TypeKey(enumType));
Assert.True(enum1.Status == ObfuscationStatus.Skipped, "Internal enum is obfuscated");
}
public void CheckSkipsVirtualMethodFromInterface()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}SkipVirtualMethodTest1.dll'>" +
@"<SkipMethod type='SkipVirtualMethodTest.Interface1' name='Method1' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("SkipVirtualMethodTest", "1", xml);
string[] expected = new string[] {
"Method1"
};
string[] notExpected = new string[] {
"Method2"
};
AssemblyHelper.CheckAssembly(Path.Combine(outputPath, "SkipVirtualMethodTest1.dll"), 2, expected, notExpected,
delegate(TypeDefinition typeDef)
{
return(!typeDef.IsInterface);
},
CheckType);
}
public void CheckSkipEnumsByName()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithEnums.dll'>" +
@"<SkipField type='TestClasses.Enum1' name='Value2' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithEnums", String.Empty, xml);
string[] expected = new string[]
{
"Value2"
};
string[] notExpected = new string[]
{
"Value1",
"ValueA"
};
CheckEnums(Path.Combine(outputPath, "AssemblyWithEnums.dll"), 1, expected, notExpected);
}
public void CheckNestedTypes()
{
var output = TestHelper.OutputPath;
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithNestedTypes.dll'>" +
@"<SkipType name='TestClasses.ClassA/NestedClassA' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, output, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes", string.Empty, xml);
HashSet <string> typesToFind = new HashSet <string>();
typesToFind.Add("A.A");
typesToFind.Add("A.A/a");
typesToFind.Add("A.A/a/A");
typesToFind.Add("A.A/NestedClassA");
AssemblyHelper.CheckAssembly(Path.Combine(output, "AssemblyWithNestedTypes.dll"), 1,
delegate { return(true); },
delegate(TypeDefinition typeDef)
{
Assert.True(typesToFind.Contains(typeDef.ToString()),
string.Format("Type {0} not expected.", typeDef.ToString()));
typesToFind.Remove(typeDef.ToString());
});
Assert.True(typesToFind.Count == 0, "Not all types found.");
}
public void CheckSkipEventsByRx()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithEvents.dll'>" +
@"<SkipEvent type='TestClasses.ClassA' rx='Event\d' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithEvents", string.Empty, xml);
string[] expected = new string[]
{
"Event1",
"Event2"
};
string[] notExpected = new string[]
{
"EventA"
};
CheckEvents(Path.Combine(outputPath, "AssemblyWithEvents.dll"), 1, expected, notExpected);
}
public void CheckSkipAllFields()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='RenameFields' value='false' />" +
@"<Module file='$(InPath){2}AssemblyWithEnums.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithEnums", String.Empty, xml);
string[] expected = new string[]
{
"Value1",
"Value2",
"ValueA"
};
string[] notExpected = new string[]
{
};
CheckEnums(Path.Combine(outputPath, "AssemblyWithEnums.dll"), 1, expected, notExpected);
}
public void CheckSkipEnums()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithEnums.dll'>" +
@"<SkipField type='TestClasses.Enum1' name='*' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithEnums", String.Empty, xml);
string[] expected = new string[] {
"Value1",
"Value2",
"ValueA"
};
string[] notExpected = new string[] {
};
CheckEnums("AssemblyWithEnums", 1, expected, notExpected);
}
public void CheckSkipsVirtualMethodFromClass()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='true' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath)\SkipVirtualMethodTest2.dll'>" +
@"<SkipMethod type='SkipVirtualMethodTest.Class1' name='Method1' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("SkipVirtualMethodTest", "2", xml);
string[] expected = new string[] {
"Method1"
};
string[] notExpected = new string[] {
"Method2"
};
AssemblyHelper.CheckAssembly("SkipVirtualMethodTest2", 2, expected, notExpected,
delegate(TypeDefinition typeDef) {
return(!typeDef.IsInterface);
},
CheckType);
}
public void CheckNestedTypes( )
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithNestedTypes.dll'>" +
@"<SkipType name='TestClasses.ClassA/NestedClassA' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes", string.Empty, xml);
C5.HashSet <string> typesToFind = new C5.HashSet <string>( );
typesToFind.Add("A.A");
typesToFind.Add("A.A/a");
typesToFind.Add("A.A/NestedClassA");
AssemblyHelper.CheckAssembly("AssemblyWithNestedTypes", 3,
delegate(TypeDefinition typeDef) { return(true); },
delegate(TypeDefinition typeDef)
{
Assert.IsTrue(typesToFind.Contains(typeDef.ToString( )), "Type {0} not expected.", typeDef.ToString( ));
typesToFind.Remove(typeDef.ToString( ));
});
Assert.IsTrue(typesToFind.Count == 0, "Not all types found.");
}
// TODO: [Test]
public void CheckSkipEventsByRx()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithEvents.dll'>" +
@"<SkipEvent type='TestClasses.ClassA' rx='Event\d' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithEvents", String.Empty, xml);
string[] expected = new string[] {
"Event1",
"Event2"
};
string[] notExpected = new string[] {
"EventA"
};
CheckEvents("AssemblyWithEvents", 1, expected, notExpected);
}
public void CheckSkipPropertyByRx()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithProperties.dll'>" +
@"<SkipProperty type='TestClasses.ClassA' rx='Property\d' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithProperties", String.Empty, xml);
string[] expected = new string[] {
"Property1",
"Property2"
};
string[] notExpected = new string[] {
"PropertyA"
};
CheckProperties("AssemblyWithProperties", 1, expected, notExpected);
}
public void CheckGenericMethodRenaming()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithGenericOverrides.dll' />" +
@"<Module file='$(InPath)\AssemblyWithGenericOverrides2.dll'>" +
@"<SkipNamespace name='*' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate(new[] { "AssemblyWithGenericOverrides", "AssemblyWithGenericOverrides2" }, xml);
var assembly2Path = Path.Combine(Directory.GetCurrentDirectory(), TestHelper.OutputPath, "AssemblyWithGenericOverrides2.dll");
var assembly2 = Assembly.LoadFile(assembly2Path);
var type = assembly2.GetType("TestClasses.Test");
var ctor = type.GetConstructor(new Type[0]);
var instance = ctor.Invoke(new object[0]);
try {
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
Assert.True(instance.ToString() == "Empty<string, string>=A<B<String, String>>",
"Generic override should have been updated");
}
finally {
AppDomain.CurrentDomain.AssemblyResolve -= AssemblyResolve;
}
}
public void CheckSkipNamespace()
{
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithTypes.dll'>" +
@"<SkipNamespace name='TestClasses1' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath, Path.DirectorySeparatorChar);
Obfuscar.Obfuscator obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml);
var map = obfuscator.Mapping;
string assmName = "AssemblyWithTypes.dll";
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, assmName));
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses1.PublicClass");
var classA = map.GetClass(new TypeKey(classAType));
Assert.True(classA.Status == ObfuscationStatus.Skipped, "Public class shouldn't have been obfuscated");
}
public void CheckHideStringsClassExists()
{
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HideStrings' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithStrings.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithStrings", string.Empty, xml, true);
AssemblyDefinition assmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.OutputPath, "AssemblyWithStrings.dll"));
Assert.Equal(4, assmDef.MainModule.Types.Count);
TypeDefinition expected = null;
foreach (var type in assmDef.MainModule.Types)
{
if (type.FullName.Contains("PrivateImplementation"))
{
expected = type;
}
}
Assert.NotNull(expected);
Assert.Equal(3, expected.Fields.Count);
Assert.Equal(6, expected.Methods.Count);
}
public void CheckHidePrivateApiTrue()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithTypes.dll'>" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml);
var map = obfuscator.Mapping;
HashSet <string> typesToFind = new HashSet <string> ();
typesToFind.Add("TestClasses.ClassA");
AssemblyHelper.CheckAssembly("AssemblyWithTypes", 2,
delegate {
return(true);
},
delegate(TypeDefinition typeDef) {
if (typesToFind.Contains(typeDef.ToString()))
{
typesToFind.Remove(typeDef.ToString());
}
});
Assert.IsTrue(typesToFind.Count == 1, "could find ClassA, which should have been obfuscated.");
}
public void CheckHidePrivateApiTrue()
{
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithTypes.dll'>" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath, Path.DirectorySeparatorChar);
var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml);
var map = obfuscator.Mapping;
string assmName = "AssemblyWithTypes.dll";
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, assmName));
var classBType = inAssmDef.MainModule.GetType("TestClasses.InternalClass");
var classB = map.GetClass(new TypeKey(classBType));
Assert.True(classB.Status == ObfuscationStatus.Renamed, "Internal class should have been obfuscated");
var enumType = inAssmDef.MainModule.GetType("TestClasses.TestEnum");
var enum1 = map.GetClass(new TypeKey(enumType));
Assert.True(enum1.Status == ObfuscationStatus.Renamed, "Internal enum should have been obfuscated");
}
public void CheckMakedOnly()
{
string name = "AssemblyWithTypesAttrs3";
string xml = string.Format(
@"<?xml version='1.0'?>" +
@" <Obfuscator>"+
@" <Var name='InPath' value='{0}' />"+
@" <Var name='OutPath' value='{1}' />"+
@" <Var name='KeepPublicApi' value='false' />" +
@" <Var name='HidePrivateApi' value='true' />" +
@" <Var name='MarkedOnly' value='true' />" +
@" <Module file='$(InPath){2}{3}.dll'>"+
@" </Module>"+
@" </Obfuscator>",
TestHelper.InputPath, TestHelper.OutputPath, Path.DirectorySeparatorChar, name);
var obfuscator = TestHelper.BuildAndObfuscate(name, string.Empty, xml);
var map = obfuscator.Mapping;
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(obfuscator.Project.AssemblyList[0].FileName);
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.TestEnum");
ObfuscatedThing classA = map.GetClass(new TypeKey(classAType));
var field = classAType.Fields.FirstOrDefault(item => item.Name == "Default");
var f1 = map.GetField(new FieldKey(field));
var field2 = classAType.Fields.FirstOrDefault(item => item.Name == "Test");
var f2 = map.GetField(new FieldKey(field2));
Assert.True(classA.Status == ObfuscationStatus.Skipped, "Public enum shouldn't have been obfuscated.");
Assert.True(f1.Status == ObfuscationStatus.Skipped, "Public enum field should not be obfuscated");
Assert.True(f2.Status == ObfuscationStatus.Skipped, "Public enum field should not be obfuscated");
TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.PublicClass");
ObfuscatedThing classB = map.GetClass(new TypeKey(classBType));
var classBmethod1 = FindByName(classBType, "PublicMethod");
var method2 = map.GetMethod(new MethodKey(classBmethod1));
Assert.True(classB.Status == ObfuscationStatus.Renamed, "PublicClass should have been obfuscated.");
Assert.True(method2.Status == ObfuscationStatus.Renamed, "PublicMethod should have been obfuscated.");
AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly(obfuscator.Project.AssemblyList[0].OutputFileName);
TypeDefinition classTypeRenamed = outAssmDef.MainModule.Types[2];
Assert.False(classTypeRenamed.CustomAttributes.Count == 2, "obfuscation attribute on type should have been removed.");
MethodDefinition testMethod = classTypeRenamed.Methods.First(_ => _.Name == "Test");
Assert.False(testMethod.HasCustomAttributes, "obfuscattion attribute on method should have been removed.");
MethodDefinition test2Method = classTypeRenamed.Methods.First(_ => _.Name == "Test2");
Assert.True(test2Method.HasCustomAttributes, "obfuscattion attribute on method should not have been removed.");
PropertyDefinition token = classTypeRenamed.Properties[0];
Assert.Equal("access_token", token.CustomAttributes[0].Properties[0].Argument.Value);
PropertyDefinition type = classTypeRenamed.Properties[1];
Assert.Equal("token_type", type.CustomAttributes[0].Properties[0].Argument.Value);
}
public void CheckGenericMethodRenaming()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithGenericOverrides.dll' />" +
@"<Module file='$(InPath){2}AssemblyWithGenericOverrides2.dll'>" +
@"<SkipNamespace name='*' />" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
var assmName = "AssemblyWithGenericOverrides";
Obfuscator obfuscator =
TestHelper.BuildAndObfuscate(new[] { assmName, "AssemblyWithGenericOverrides2" },
xml);
var map = obfuscator.Mapping;
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, $"{assmName}.dll"));
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.Alpha`1");
TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.IBeta`2");
var classARenamed = map.GetClass(new TypeKey(classAType));
var classBRenamed = map.GetClass(new TypeKey(classBType));
var end = assmName.Length + 2;
Assert.True(classARenamed.Status == ObfuscationStatus.Renamed, "Type must be obfuscated");
Assert.True(classBRenamed.Status == ObfuscationStatus.Renamed, "Interface must be obfuscated");
var newNameA = classARenamed.StatusText.Substring(end);
var newNameB = classBRenamed.StatusText.Substring(end);
var formattedString = $"Empty<string, string>={newNameA}[{newNameB}[System.String,System.String]]";
var assembly2Path = Path.Combine(Directory.GetCurrentDirectory(), outputPath,
"AssemblyWithGenericOverrides2.dll");
var assembly2 = Assembly.LoadFile(assembly2Path);
var type = assembly2.GetType("TestClasses.Test");
var ctor = type.GetConstructor(new Type[0]);
var instance = ctor.Invoke(new object[0]);
try
{
output = outputPath;
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
Assert.True(instance.ToString() == formattedString,
"Generic override should have been updated");
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= AssemblyResolve;
}
}
public void BuildAndObfuscateAssemblies()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithAttrs.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithAttrs", String.Empty, xml);
}
public CustomAttributeTests()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath)\AssemblyWithCustomAttr.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate("AssemblyWithCustomAttr", String.Empty, xml);
}
Obfuscator BuildAndObfuscateAssemblies()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithOverrides.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath, Path.DirectorySeparatorChar);
return(TestHelper.BuildAndObfuscate("AssemblyWithOverrides", String.Empty, xml));
}
public CustomAttributeWithArgTests()
{
var xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithCustomAttrTypeArg.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath, Path.DirectorySeparatorChar);
TestHelper.BuildAndObfuscate("AssemblyWithCustomAttrTypeArg", String.Empty, xml);
}
public void CheckEventRenaming()
{
string outputPath = TestHelper.OutputPath;
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='KeepPublicApi' value='true' />" +
@"<Var name='HidePrivateApi' value='true' />" +
@"<Module file='$(InPath){2}AssemblyWithEvent.dll' />" +
@"<Module file='$(InPath){2}AssemblyWithEvent2.dll'>" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar);
var assmName = "AssemblyWithEvent";
Obfuscator obfuscator =
TestHelper.BuildAndObfuscate(new[] { assmName, "AssemblyWithEvent2" },
xml);
var map = obfuscator.Mapping;
{
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, $"{assmName}.dll"));
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ITest");
var classARenamed = map.GetClass(new TypeKey(classAType));
Assert.True(classARenamed.Status == ObfuscationStatus.Skipped, "Type must not be obfuscated");
var classAEvent = classAType.Events.First(item => item.Name == "TestEvent");
var classAEventRenamed = map.GetEvent(new EventKey(classAEvent));
Assert.True(classAEventRenamed.Status == ObfuscationStatus.Skipped, "Interface event must not be obfuscated");
}
{
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, $"{assmName}2.dll"));
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.Test");
var classARenamed = map.GetClass(new TypeKey(classAType));
Assert.True(classARenamed.Status == ObfuscationStatus.Renamed, "Type must be obfuscated");
var classAEvent = classAType.Events.First(item => item.Name == "TestEvent");
var classAEventRenamed = map.GetEvent(new EventKey(classAEvent));
Assert.True(classAEventRenamed.Status == ObfuscationStatus.Skipped, "Class event must not be obfuscated");
}
//var assembly2Path = Path.Combine(Directory.GetCurrentDirectory(), outputPath,
// "AssemblyWithEvent2.dll");
//var assembly2 = Assembly.LoadFile(assembly2Path);
//var type = assembly2.GetType("A.A");
//var ctor = type.GetConstructor(new Type[0]);
//var instance = ctor.Invoke(new object[0]);
}
Obfuscar.ObfuscationMap BuildAndObfuscateAssemblies( )
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath)\AssemblyWithSpecializedGenerics.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
Obfuscar.Obfuscator obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithSpecializedGenerics", String.Empty, xml);
return(obfuscator.Mapping);
}
public void CheckHidePrivateApiFalse()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='HidePrivateApi' value='false' />" +
@"<Module file='$(InPath)\AssemblyWithTypes.dll'>" +
@"</Module>" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml);
var map = obfuscator.Mapping;
HashSet <string> typesToFind = new HashSet <string> ();
typesToFind.Add("TestClasses.ClassA");
AssemblyHelper.CheckAssembly("AssemblyWithTypes", 2,
delegate {
return(true);
},
delegate(TypeDefinition typeDef) {
if (typesToFind.Contains(typeDef.ToString()))
{
typesToFind.Remove(typeDef.ToString());
}
});
Assert.IsTrue(typesToFind.Count == 1, "could not find ClassA, which should not have been obfuscated.");
string assmName = "AssemblyWithTypes.dll";
AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.InputPath, assmName));
AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly(
Path.Combine(TestHelper.OutputPath, assmName));
TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ClassB");
MethodDefinition classAmethod1 = FindByName(classAType, "TestA");
MethodDefinition classAmethod2 = FindByName(classAType, "TestB");
ObfuscatedThing classAMethod1 = map.GetMethod(new MethodKey(classAmethod1));
ObfuscatedThing classAMethod2 = map.GetMethod(new MethodKey(classAmethod2));
Assert.IsTrue(classAMethod1.Status == ObfuscationStatus.Skipped, "private method is obfuscated.");
Assert.IsTrue(classAMethod2.Status == ObfuscationStatus.Renamed, "pubilc method is not obfuscated.");
}
public string BuildAndObfuscateAssemblies()
{
var output = TestHelper.OutputPath;
var name = "AssemblyWithAttrs";
string xml = string.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Module file='$(InPath){2}{3}.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, output, Path.DirectorySeparatorChar, name);
TestHelper.BuildAndObfuscate(name, String.Empty, xml);
return(Path.Combine(output, $"{name}.dll"));
}
public void BuildAndObfuscateAssemblies()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@"<Obfuscator>" +
@"<Var name='InPath' value='{0}' />" +
@"<Var name='OutPath' value='{1}' />" +
@"<Var name='ReuseNames' value='true' />" +
@"<Var name='KeepPublicApi' value='false' />" +
@"<Module file='$(InPath)\AssemblyForCleanPoolClass.dll' />" +
@"<Module file='$(InPath)\AssemblyForCleanPoolInterface.dll' />" +
@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
TestHelper.BuildAndObfuscate(new[] { "AssemblyForCleanPoolInterface", "AssemblyForCleanPoolClass" }, xml);
}
public void CheckException()
{
string xml = String.Format(
@"<?xml version='1.0'?>" +
@" <Obfuscator>"+
@" <Var name='InPath' value='{0}' />"+
@" <Var name='OutPath' value='{1}' />"+
@"<Var name='HidePrivateApi' value='true' />" +
@" <Module file='$(InPath)\AssemblyWithTypesAttrs2.dll'>"+
@" </Module>"+
@" </Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);
var exception = Assert.Throws <ObfuscarException> (() => TestHelper.BuildAndObfuscate("AssemblyWithTypesAttrs2", string.Empty, xml));
Assert.True(exception.Message.StartsWith("Inconsistent virtual method obfuscation"));
}
