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); Assert.False(outAssmDef.CustomAttributes.Count > 2, "obfuscation attribute on assembly should have been removed."); 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, "obfuscation attribute on method should have been removed."); MethodDefinition test2Method = classTypeRenamed.Methods.First(_ => _.Name == "Test2"); Assert.True(test2Method.HasCustomAttributes, "obfuscation 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 CheckInterfaces() { Obfuscator item = BuildAndObfuscateAssemblies("AssemblyWithInterfaces"); ObfuscationMap map = item.Mapping; string assmName = "AssemblyWithInterfaces.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(item.Project.Settings.OutPath, assmName)); { TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.C"); MethodDefinition method = FindMethodByName(classCType, "Method"); PropertyDefinition property = FindPropertyByName(classCType, "Property"); ObfuscatedThing methodEntry = map.GetMethod(new MethodKey(method)); ObfuscatedThing propertyEntry = map.GetProperty(new PropertyKey(new TypeKey(classCType), property)); Assert.True(methodEntry.Status == ObfuscationStatus.Skipped, "public interface method should not be obfuscated."); Assert.True(propertyEntry.Status == ObfuscationStatus.Skipped, "public interface property should not be obfuscated."); } }
public void CheckClassHasAttribute() { Obfuscator item = BuildAndObfuscateAssemblies(); ObfuscationMap map = item.Mapping; string assmName = "AssemblyWithSpecializedGenerics.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(item.Project.Settings.OutPath, assmName)); { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ClassA`1"); MethodDefinition classAmethod2 = FindByName(classAType, "Method2"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.ClassB"); MethodDefinition classBmethod2 = FindByName(classBType, "Method2"); ObfuscatedThing classAEntry = map.GetMethod(new MethodKey(classAmethod2)); ObfuscatedThing classBEntry = map.GetMethod(new MethodKey(classBmethod2)); Assert.True( classAEntry.Status == ObfuscationStatus.Renamed && classBEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True( classAEntry.StatusText == classBEntry.StatusText, "Both methods should have been renamed to the same thing."); } { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ClassA`1"); MethodDefinition classAmethod2 = FindByName(classAType, "Method3"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.ClassB"); MethodDefinition classBmethod2 = FindByName(classBType, "Method3"); ObfuscatedThing classAEntry = map.GetMethod(new MethodKey(classAmethod2)); ObfuscatedThing classBEntry = map.GetMethod(new MethodKey(classBmethod2)); Assert.True( classAEntry.Status == ObfuscationStatus.Renamed && classBEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True( classAEntry.StatusText == classBEntry.StatusText, "Both methods should have been renamed to the same thing."); } }
public void CheckClassHasAttribute() { Obfuscar.ObfuscationMap map = BuildAndObfuscateAssemblies(); string assmName = "AssemblyWithOverrides.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.ClassA"); MethodDefinition classAmethod2 = FindByName(classAType, "Method2"); MethodDefinition classAcompare = FindByName(classAType, "CompareTo"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.ClassB"); MethodDefinition classBmethod2 = FindByName(classBType, "Method2"); MethodDefinition classBcompare = FindByName(classBType, "CompareTo"); TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.ClassC"); MethodDefinition classCmethod1 = FindByName(classCType, "Method1"); TypeDefinition classDType = inAssmDef.MainModule.GetType("TestClasses.ClassD"); MethodDefinition classDmethod1 = FindByName(classDType, "Method1"); Obfuscar.ObfuscatedThing classAEntry = map.GetMethod(new Obfuscar.MethodKey(classAmethod2)); ObfuscatedThing classAEntry1 = map.GetMethod(new MethodKey(classAcompare)); Obfuscar.ObfuscatedThing classBEntry = map.GetMethod(new Obfuscar.MethodKey(classBmethod2)); Obfuscar.ObfuscatedThing classBEntry1 = map.GetMethod(new Obfuscar.MethodKey(classBcompare)); ObfuscatedThing classCEntry = map.GetMethod(new MethodKey(classCmethod1)); ObfuscatedThing classDEntry = map.GetMethod(new MethodKey(classDmethod1)); Assert.IsTrue( classAEntry.Status == Obfuscar.ObfuscationStatus.Renamed && classBEntry.Status == Obfuscar.ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.IsTrue( classAEntry.StatusText == classBEntry.StatusText, "Both methods should have been renamed to the same thing."); Assert.IsTrue(classAEntry1.Status == ObfuscationStatus.Skipped); Assert.IsTrue(classBEntry1.Status == ObfuscationStatus.Skipped); Assert.IsTrue(classCEntry.Status == ObfuscationStatus.Renamed); Assert.IsTrue(classDEntry.Status == ObfuscationStatus.Renamed); }
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 void CheckKeepPublicApiTrue() { 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}AssemblyWithTypes.dll'>" + @"</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("TestClasses.PublicClass"); MethodDefinition classAmethod1 = FindByName(classAType, "PrivateMethod"); MethodDefinition classAmethod2 = FindByName(classAType, "PublicMethod"); MethodDefinition classAmethod3 = FindByName(classAType, "InternalProtectedMethod"); ObfuscatedThing classAMethod1 = map.GetMethod(new MethodKey(classAmethod1)); ObfuscatedThing classAMethod2 = map.GetMethod(new MethodKey(classAmethod2)); ObfuscatedThing classAMethod3 = map.GetMethod(new MethodKey(classAmethod3)); var classA = map.GetClass(new TypeKey(classAType)); Assert.True(classA.Status == ObfuscationStatus.Skipped, "Public class shouldn't have been obfuscated"); Assert.True(classAMethod1.Status == ObfuscationStatus.Renamed, "private method is not obfuscated."); Assert.True(classAMethod2.Status == ObfuscationStatus.Skipped, "pubilc method is obfuscated."); Assert.True(classAMethod3.Status == ObfuscationStatus.Skipped, "internal protected method is obfuscated."); var protectedMethod = FindByName(classAType, "ProtectedMethod"); var protectedAfter = map.GetMethod(new MethodKey(protectedMethod)); Assert.True(protectedAfter.Status == ObfuscationStatus.Skipped, "protected method is obfuscated."); }
public void CheckMakedOnly() { 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)\AssemblyWithTypesAttrs3.dll'>" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypesAttrs3", string.Empty, xml); var map = obfuscator.Mapping; const string assmName = "AssemblyWithTypesAttrs3.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); 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."); }
public void CheckExclusion() { 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)\AssemblyWithTypesAttrs.dll'>"+ @" </Module>"+ @" </Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypesAttrs", string.Empty, xml); var map = obfuscator.Mapping; const string assmName = "AssemblyWithTypesAttrs.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.InternalClass"); ObfuscatedThing classA = map.GetClass(new TypeKey(classAType)); var classAmethod1 = FindByName(classAType, "PublicMethod"); var method = map.GetMethod(new MethodKey(classAmethod1)); TypeDefinition nestedClassAType = classAType.NestedTypes [0]; ObfuscatedThing nestedClassA = map.GetClass(new TypeKey(nestedClassAType)); TypeDefinition nestedClassAType2 = nestedClassAType.NestedTypes [0]; ObfuscatedThing nestedClassA2 = map.GetClass(new TypeKey(nestedClassAType2)); Assert.True(classA.Status == ObfuscationStatus.Skipped, "InternalClass shouldn't have been obfuscated."); Assert.True(method.Status == ObfuscationStatus.Skipped, "PublicMethod shouldn't have been obfuscated"); Assert.True(nestedClassA.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); Assert.True(nestedClassA2.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); } { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.InternalClass3"); ObfuscatedThing classA = map.GetClass(new TypeKey(classAType)); var classAmethod1 = FindByName(classAType, "PublicMethod"); var method = map.GetMethod(new MethodKey(classAmethod1)); TypeDefinition nestedClassAType = classAType.NestedTypes [0]; ObfuscatedThing nestedClassA = map.GetClass(new TypeKey(nestedClassAType)); TypeDefinition nestedClassAType2 = nestedClassAType.NestedTypes [0]; ObfuscatedThing nestedClassA2 = map.GetClass(new TypeKey(nestedClassAType2)); Assert.True(classA.Status == ObfuscationStatus.Skipped, "InternalClass shouldn't have been obfuscated."); Assert.True(method.Status == ObfuscationStatus.Renamed, "PublicMethod should have been obfuscated"); Assert.True(nestedClassA.Status == ObfuscationStatus.Renamed, "Nested class should have been obfuscated"); Assert.True(nestedClassA2.Status == ObfuscationStatus.Renamed, "Nested class should have been 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."); TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.InternalClass2"); ObfuscatedThing classC = map.GetClass(new TypeKey(classCType)); var classCmethod1 = FindByName(classCType, "PublicMethod"); var method1 = map.GetMethod(new MethodKey(classCmethod1)); TypeDefinition nestedClassBType = classCType.NestedTypes [0]; ObfuscatedThing nestedClassB = map.GetClass(new TypeKey(nestedClassBType)); TypeDefinition nestedClassBType2 = nestedClassBType.NestedTypes [0]; ObfuscatedThing nestedClassB2 = map.GetClass(new TypeKey(nestedClassBType2)); Assert.True(classC.Status == ObfuscationStatus.Renamed, "InternalClass2 should have been obfuscated."); Assert.True(method1.Status == ObfuscationStatus.Skipped, "PublicMethod shouldn't have been obfuscated."); Assert.True(nestedClassB.Status == ObfuscationStatus.Renamed, "Nested class should have been obfuscated"); Assert.True(nestedClassB2.Status == ObfuscationStatus.Renamed, "Nested class should have been obfuscated"); TypeDefinition classDType = inAssmDef.MainModule.GetType("TestClasses.PublicClass2"); ObfuscatedThing classD = map.GetClass(new TypeKey(classDType)); var classDmethod1 = FindByName(classDType, "PublicMethod"); var method3 = map.GetMethod(new MethodKey(classDmethod1)); Assert.True(classD.Status == ObfuscationStatus.Skipped, "PublicClass2 shouldn't have been obfuscated."); Assert.True(method3.Status == ObfuscationStatus.Renamed, "PublicMethod should have been obfuscated."); }
public void CheckClassHasAttribute() { Obfuscator item = BuildAndObfuscateAssemblies(); ObfuscationMap map = item.Mapping; string assmName = "AssemblyWithOverrides.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(item.Project.Settings.OutPath, assmName)); { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ClassA"); MethodDefinition classAmethod2 = FindByName(classAType, "Method2"); MethodDefinition classAcompare = FindByName(classAType, "CompareTo"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.ClassB"); MethodDefinition classBmethod2 = FindByName(classBType, "Method2"); MethodDefinition classBcompare = FindByName(classBType, "CompareTo"); TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.ClassC"); MethodDefinition classCmethod1 = FindByName(classCType, "Method1"); TypeDefinition classDType = inAssmDef.MainModule.GetType("TestClasses.ClassD"); MethodDefinition classDmethod1 = FindByName(classDType, "Method1"); ObfuscatedThing classAEntry = map.GetMethod(new MethodKey(classAmethod2)); ObfuscatedThing classACompareEntry = map.GetMethod(new MethodKey(classAcompare)); ObfuscatedThing classBEntry = map.GetMethod(new MethodKey(classBmethod2)); ObfuscatedThing classBCompareEntry = map.GetMethod(new MethodKey(classBcompare)); ObfuscatedThing classCEntry = map.GetMethod(new MethodKey(classCmethod1)); ObfuscatedThing classDEntry = map.GetMethod(new MethodKey(classDmethod1)); var classFType = inAssmDef.MainModule.GetType("TestClasses.ClassF"); var classFmethod = FindByName(classFType, "Test"); var classGType = inAssmDef.MainModule.GetType("TestClasses.ClassG"); var classGmethod = FindByName(classGType, "Test"); var classFEntry = map.GetMethod(new MethodKey(classFmethod)); var classGEntry = map.GetMethod(new MethodKey(classGmethod)); Assert.True( classAEntry.Status == ObfuscationStatus.Renamed && classBEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True( classAEntry.StatusText == classBEntry.StatusText, "Both methods should have been renamed to the same thing."); Assert.True(classACompareEntry.Status == ObfuscationStatus.Skipped); Assert.True(classBCompareEntry.Status == ObfuscationStatus.Skipped); Assert.True(classCEntry.Status == ObfuscationStatus.Renamed); Assert.True(classDEntry.Status == ObfuscationStatus.Renamed); Assert.True( classFEntry.Status == ObfuscationStatus.Renamed && classGEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True(classFEntry.StatusText == classGEntry.StatusText, "Both methods should have been renamed to the same thing."); } { TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.CA"); MethodDefinition classAmethod2 = FindByName(classAType, "get_PropA"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.CB"); MethodDefinition classBmethod2 = FindByName(classBType, "get_PropB"); TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.IA"); MethodDefinition classCmethod1 = FindByName(classCType, "get_PropA"); TypeDefinition classDType = inAssmDef.MainModule.GetType("TestClasses.IB"); MethodDefinition classDmethod1 = FindByName(classDType, "get_PropB"); ObfuscatedThing classAEntry = map.GetMethod(new MethodKey(classAmethod2)); ObfuscatedThing classBEntry = map.GetMethod(new MethodKey(classBmethod2)); ObfuscatedThing classCEntry = map.GetMethod(new MethodKey(classCmethod1)); ObfuscatedThing classDEntry = map.GetMethod(new MethodKey(classDmethod1)); Assert.True( classAEntry.Status == ObfuscationStatus.Renamed && classCEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True( classAEntry.StatusText == classCEntry.StatusText, "Both methods should have been renamed to the same thing."); Assert.True( classBEntry.Status == ObfuscationStatus.Renamed && classDEntry.Status == ObfuscationStatus.Renamed, "Both methods should have been renamed."); Assert.True(classBEntry.StatusText == classDEntry.StatusText, "Both methods should have been renamed to the same thing."); Assert.True(classAEntry.StatusText != classBEntry.StatusText, "Both methods shouldn't have been renamed to the same thing."); } }
public void CheckMarkedOnly2() { 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' />" + @" <Var name='MarkedOnly' value='true' />" + @" <Module file='$(InPath){2}AssemblyWithTypesAttrs.dll'>"+ @" </Module>"+ @" </Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar); var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypesAttrs", string.Empty, xml); var map = obfuscator.Mapping; const string assmName = "AssemblyWithTypesAttrs.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.InternalClass"); ObfuscatedThing classA = map.GetClass(new TypeKey(classAType)); var classAmethod1 = FindByName(classAType, "PublicMethod"); var method = map.GetMethod(new MethodKey(classAmethod1)); TypeDefinition nestedClassAType = classAType.NestedTypes[0]; ObfuscatedThing nestedClassA = map.GetClass(new TypeKey(nestedClassAType)); TypeDefinition nestedClassAType2 = nestedClassAType.NestedTypes[0]; ObfuscatedThing nestedClassA2 = map.GetClass(new TypeKey(nestedClassAType2)); Assert.True(classA.Status == ObfuscationStatus.Skipped, "InternalClass shouldn't have been obfuscated."); Assert.True(method.Status == ObfuscationStatus.Skipped, "PublicMethod shouldn't have been obfuscated"); Assert.True(nestedClassA.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); Assert.True(nestedClassA2.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.PublicClass"); Assert.True(classBType.HasCustomAttributes, "Obfuscation attribute must exist"); 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( Path.Combine(outputPath, assmName)); TypeDefinition renamed = outAssmDef.MainModule.GetType(classB.StatusText.Substring(assmName.Length - 4 + 2)); Assert.False(renamed.HasCustomAttributes, "Obfuscation attribute must not exist"); TypeDefinition classCType = inAssmDef.MainModule.GetType("TestClasses.InternalClass2"); ObfuscatedThing classC = map.GetClass(new TypeKey(classCType)); var classCmethod1 = FindByName(classCType, "PublicMethod"); var method1 = map.GetMethod(new MethodKey(classCmethod1)); TypeDefinition nestedClassBType = classCType.NestedTypes[0]; ObfuscatedThing nestedClassB = map.GetClass(new TypeKey(nestedClassBType)); TypeDefinition nestedClassBType2 = nestedClassBType.NestedTypes[0]; ObfuscatedThing nestedClassB2 = map.GetClass(new TypeKey(nestedClassBType2)); Assert.True(classC.Status == ObfuscationStatus.Skipped, "InternalClass2 shouldn't have been obfuscated."); Assert.True(method1.Status == ObfuscationStatus.Skipped, "PublicMethod shouldn't have been obfuscated."); Assert.True(nestedClassB.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); Assert.True(nestedClassB2.Status == ObfuscationStatus.Skipped, "Nested class shouldn't have been obfuscated"); TypeDefinition classDType = inAssmDef.MainModule.GetType("TestClasses.PublicClass2"); ObfuscatedThing classD = map.GetClass(new TypeKey(classDType)); var classDmethod1 = FindByName(classDType, "PublicMethod"); var method3 = map.GetMethod(new MethodKey(classDmethod1)); Assert.True(classD.Status == ObfuscationStatus.Skipped, "PublicClass2 shouldn't have been obfuscated."); Assert.True(method3.Status == ObfuscationStatus.Renamed, "PublicMethod should have been obfuscated."); }
public void CheckSkipSerializableTypes() { 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='SkipSerializableTypes' value='true' />" + @" <Module file='$(InPath){2}{3}.dll' />" + @"</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)); Assert.Equal(ObfuscationStatus.Renamed, classA.Status); var enumField = classAType.Fields.FirstOrDefault(item => item.Name == "Default"); var f1 = map.GetField(new FieldKey(enumField)); Assert.Equal(ObfuscationStatus.Renamed, f1.Status); var enumField2 = classAType.Fields.FirstOrDefault(item => item.Name == "Test"); var f2 = map.GetField(new FieldKey(enumField2)); Assert.Equal(ObfuscationStatus.Renamed, f2.Status); TypeDefinition classBType = inAssmDef.MainModule.GetType("TestClasses.PublicClass"); var classBTypeKey = new TypeKey(classBType); ObfuscatedThing classB = map.GetClass(classBTypeKey); Assert.Equal(ObfuscationStatus.Skipped, classB.Status); var classBmethod1 = FindMethod(classBType, "PublicMethod"); var method1 = map.GetMethod(new MethodKey(classBmethod1)); Assert.Equal(ObfuscationStatus.Renamed, method1.Status); var classBproperty1 = FindProperty(classBType, "TestInt"); var property1 = map.GetProperty(new PropertyKey(classBTypeKey, classBproperty1)); Assert.Equal(ObfuscationStatus.Skipped, property1.Status); var classBfield1 = FindField(classBType, "TestSerializedField"); var field1 = map.GetField(new FieldKey(classBfield1)); Assert.Equal(ObfuscationStatus.Skipped, field1.Status); var classBfield2 = FindField(classBType, "TestNonSerializedField"); var field2 = map.GetField(new FieldKey(classBfield2)); Assert.Equal(ObfuscationStatus.Renamed, field2.Status); }