From 9a7d28472d23100a1b68dda5d92668b375e3f690 Mon Sep 17 00:00:00 2001 From: de4dot Date: Tue, 3 Jan 2012 19:52:40 +0100 Subject: [PATCH] Remove new lines when printing method/type names --- de4dot.code/MethodReturnValueInliner.cs | 9 +++- de4dot.code/ObfuscatedFile.cs | 10 ++-- de4dot.code/Utils.cs | 8 +++ de4dot.code/deobfuscators/DeobfuscatorBase.cs | 31 ++++++++--- .../Dotfuscator/StringDecrypter.cs | 2 +- .../deobfuscators/ProxyDelegateFinderBase.cs | 14 +++-- .../SmartAssembly/TamperProtectionRemover.cs | 2 +- de4dot.code/deobfuscators/TypesRestorer.cs | 6 +-- de4dot.code/renamer/Renamer.cs | 54 +++++++++---------- de4dot.code/renamer/asmmodules/Modules.cs | 6 +-- de4dot.code/renamer/asmmodules/TypeDef.cs | 4 +- 11 files changed, 91 insertions(+), 55 deletions(-) diff --git a/de4dot.code/MethodReturnValueInliner.cs b/de4dot.code/MethodReturnValueInliner.cs index 5b4eeaba..74490300 100644 --- a/de4dot.code/MethodReturnValueInliner.cs +++ b/de4dot.code/MethodReturnValueInliner.cs @@ -242,7 +242,9 @@ namespace de4dot.code { // We're here if there were no cflow deobfuscation, or if there are two or // more blocks branching to the decrypter method, or the two blocks can't be // merged because one is outside the exception handler (eg. buggy obfuscator). - Log.v("Could not find all arguments to method {0}", method); + Log.v("Could not find all arguments to method {0} ({1:X8})", + Utils.removeNewlines(method), + method.MetadataToken.ToInt32()); return false; } @@ -288,7 +290,10 @@ namespace de4dot.code { break; default: - Log.v("Could not find all arguments to method {0}, instr: {1}", method, instr); + Log.v("Could not find all arguments to method {0} ({1:X8}), instr: {2}", + Utils.removeNewlines(method), + method.MetadataToken.ToInt32(), + instr); return false; } break; diff --git a/de4dot.code/ObfuscatedFile.cs b/de4dot.code/ObfuscatedFile.cs index d580a77f..98cb5f80 100644 --- a/de4dot.code/ObfuscatedFile.cs +++ b/de4dot.code/ObfuscatedFile.cs @@ -445,7 +445,7 @@ namespace de4dot.code { } } - Log.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MetadataToken.ToInt32(), method.FullName); + Log.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MetadataToken.ToInt32(), Utils.removeNewlines(method.FullName)); tokens.Add(method.MetadataToken.ToInt32()); } } @@ -527,7 +527,7 @@ namespace de4dot.code { var methodPrinter = new MethodPrinter(); var cflowDeobfuscator = new BlocksCflowDeobfuscator { InlineMethods = deob.CanInlineMethods }; foreach (var method in allMethods) { - Log.v("Deobfuscating {0} ({1:X8})", method, method.MetadataToken.ToUInt32()); + Log.v("Deobfuscating {0} ({1:X8})", Utils.removeNewlines(method), method.MetadataToken.ToUInt32()); Log.indent(); try { @@ -708,9 +708,9 @@ namespace de4dot.code { if (operandString == "") Log.log(logLevel, "{0}", instrString); else if (memberReference != null) - Log.log(logLevel, "{0,-9} {1} // {2:X8}", instrString, operandString, memberReference.MetadataToken.ToUInt32()); + Log.log(logLevel, "{0,-9} {1} // {2:X8}", instrString, Utils.removeNewlines(operandString), memberReference.MetadataToken.ToUInt32()); else - Log.log(logLevel, "{0,-9} {1}", instrString, operandString); + Log.log(logLevel, "{0,-9} {1}", instrString, Utils.removeNewlines(operandString)); } printExInfo(lastExInfo); Log.deIndent(); @@ -859,7 +859,7 @@ namespace de4dot.code { if (savedMethodBodies != null) savedMethodBodies.save(method); - Log.v("{0}: {1} ({2:X8})", msg, method, method.MetadataToken.ToUInt32()); + Log.v("{0}: {1} ({2:X8})", msg, Utils.removeNewlines(method), method.MetadataToken.ToUInt32()); Log.indent(); if (hasNonEmptyBody(method)) { diff --git a/de4dot.code/Utils.cs b/de4dot.code/Utils.cs index e9034c7a..ce069f69 100644 --- a/de4dot.code/Utils.cs +++ b/de4dot.code/Utils.cs @@ -107,6 +107,14 @@ namespace de4dot.code { sb.Append(c); } + public static string removeNewlines(object o) { + return removeNewlines(o.ToString()); + } + + public static string removeNewlines(string s) { + return s.Replace('\n', ' ').Replace('\r', ' '); + } + public static string getFullPath(string path) { try { return Path.GetFullPath(path); diff --git a/de4dot.code/deobfuscators/DeobfuscatorBase.cs b/de4dot.code/deobfuscators/DeobfuscatorBase.cs index 87e07832..8b80a7ed 100644 --- a/de4dot.code/deobfuscators/DeobfuscatorBase.cs +++ b/de4dot.code/deobfuscators/DeobfuscatorBase.cs @@ -239,7 +239,7 @@ namespace de4dot.code.deobfuscators { continue; if (info.find(destMethod)) { - Log.v("Removed call to {0}", destMethod); + Log.v("Removed call to {0}", Utils.removeNewlines(destMethod)); instrsToDelete.Add(i); } } @@ -329,7 +329,10 @@ namespace de4dot.code.deobfuscators { foreach (var cctor in emptyCctorsToRemove) { var type = cctor.DeclaringType; if (type.Methods.Remove(cctor)) - Log.v("{0:X8}, type: {1} ({2:X8})", cctor.MetadataToken.ToUInt32(), type, type.MetadataToken.ToUInt32()); + Log.v("{0:X8}, type: {1} ({2:X8})", + cctor.MetadataToken.ToUInt32(), + Utils.removeNewlines(type), + type.MetadataToken.ToUInt32()); } Log.deIndent(); } @@ -346,7 +349,11 @@ namespace de4dot.code.deobfuscators { continue; var type = method.DeclaringType; if (type.Methods.Remove(method)) - Log.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})", method, method.MetadataToken.ToUInt32(), type, info.reason); + Log.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})", + Utils.removeNewlines(method), + method.MetadataToken.ToUInt32(), + Utils.removeNewlines(type), + info.reason); } Log.deIndent(); } @@ -363,7 +370,11 @@ namespace de4dot.code.deobfuscators { continue; var type = field.DeclaringType; if (type.Fields.Remove(field)) - Log.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})", field, field.MetadataToken.ToUInt32(), type, info.reason); + Log.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})", + Utils.removeNewlines(field), + field.MetadataToken.ToUInt32(), + Utils.removeNewlines(type), + info.reason); } Log.deIndent(); } @@ -385,7 +396,10 @@ namespace de4dot.code.deobfuscators { else removed = types.Remove(typeDef); if (removed) - Log.v("Removed type {0} ({1:X8}) (reason: {2})", typeDef, typeDef.MetadataToken.ToUInt32(), info.reason); + Log.v("Removed type {0} ({1:X8}) (reason: {2})", + Utils.removeNewlines(typeDef), + typeDef.MetadataToken.ToUInt32(), + info.reason); } Log.deIndent(); } @@ -412,7 +426,10 @@ namespace de4dot.code.deobfuscators { for (int i = 0; i < customAttrs.Count; i++) { if (MemberReferenceHelper.compareTypes(customAttrs[i].AttributeType, typeDef)) { customAttrs.RemoveAt(i); - Log.v("Removed custom attribute {0} ({1:X8}) (reason: {2})", typeDef, typeDef.MetadataToken.ToUInt32(), info.reason); + Log.v("Removed custom attribute {0} ({1:X8}) (reason: {2})", + Utils.removeNewlines(typeDef), + typeDef.MetadataToken.ToUInt32(), + info.reason); break; } } @@ -432,7 +449,7 @@ namespace de4dot.code.deobfuscators { for (int i = customAttributes.Count - 1; i >= 0; i--) { var attr = customAttributes[i].AttributeType; if (attr.FullName == "System.Runtime.CompilerServices.SuppressIldasmAttribute") { - Log.v("Removed attribute {0}", attr.FullName); + Log.v("Removed attribute {0}", Utils.removeNewlines(attr.FullName)); customAttributes.RemoveAt(i); } } diff --git a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs index 1b5f8293..251003e7 100644 --- a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs +++ b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs @@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator { var info = new StringDecrypterInfo(method, DotNetUtils.getLdcI4Value(ldci4)); stringDecrypterMethods[info.method] = info; - Log.v("Found string decrypter method: {0}, magic: 0x{1:X8}", info.method, info.magic); + Log.v("Found string decrypter method: {0}, magic: 0x{1:X8}", Utils.removeNewlines(info.method), info.magic); break; } } diff --git a/de4dot.code/deobfuscators/ProxyDelegateFinderBase.cs b/de4dot.code/deobfuscators/ProxyDelegateFinderBase.cs index f4c4785a..5b7a1e6c 100644 --- a/de4dot.code/deobfuscators/ProxyDelegateFinderBase.cs +++ b/de4dot.code/deobfuscators/ProxyDelegateFinderBase.cs @@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators { if (context == null) continue; - Log.v("Found proxy delegate: {0} ({1:X8})", type, type.MetadataToken.ToUInt32()); + Log.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MetadataToken.ToUInt32()); RemovedDelegateCreatorCalls++; onFoundProxyDelegate(type); @@ -116,7 +116,11 @@ namespace de4dot.code.deobfuscators { if (calledMethod == null) continue; addDelegateInfo(new DelegateInfo(field, calledMethod, callOpcode)); - Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})", field.Name, callOpcode, calledMethod, calledMethod.MetadataToken.ToUInt32()); + Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})", + Utils.removeNewlines(field.Name), + callOpcode, + Utils.removeNewlines(calledMethod), + calledMethod.MetadataToken.ToUInt32()); } Log.deIndent(); delegateTypesDict[type] = true; @@ -182,8 +186,10 @@ namespace de4dot.code.deobfuscators { else { errors++; Log.w("Could not fix proxy call. Method: {0} ({1:X8}), Proxy type: {2} ({3:X8})", - blocks.Method, blocks.Method.MetadataToken.ToInt32(), - di.field.DeclaringType, di.field.DeclaringType.MetadataToken.ToInt32()); + Utils.removeNewlines(blocks.Method), + blocks.Method.MetadataToken.ToInt32(), + Utils.removeNewlines(di.field.DeclaringType), + di.field.DeclaringType.MetadataToken.ToInt32()); } } else if (instr.OpCode == OpCodes.Call) { diff --git a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs index b6588e38..4fde6108 100644 --- a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs +++ b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs @@ -296,7 +296,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly { if (tamperBlocks == null) { if (isTamperProtected(allBlocks)) - Log.w("Could not remove tamper protection code: {0} ({1:X8})", blocks.Method, blocks.Method.MetadataToken.ToUInt32()); + Log.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.removeNewlines(blocks.Method), blocks.Method.MetadataToken.ToUInt32()); return false; } diff --git a/de4dot.code/deobfuscators/TypesRestorer.cs b/de4dot.code/deobfuscators/TypesRestorer.cs index d6a69522..b4e2c19e 100644 --- a/de4dot.code/deobfuscators/TypesRestorer.cs +++ b/de4dot.code/deobfuscators/TypesRestorer.cs @@ -157,7 +157,7 @@ namespace de4dot.code.deobfuscators { fields.Sort((a, b) => Utils.compareInt32(a.token, b.token)); Log.indent(); foreach (var updatedField in fields) - Log.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, updatedField.newFieldType.FullName, updatedField.newFieldType.MetadataToken.ToInt32()); + Log.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, Utils.removeNewlines(updatedField.newFieldType.FullName), updatedField.newFieldType.MetadataToken.ToInt32()); Log.deIndent(); } @@ -170,12 +170,12 @@ namespace de4dot.code.deobfuscators { Log.v("Method {0:X8}", updatedMethod.token); Log.indent(); if (updatedMethod.newReturnType != null) - Log.v("ret: {0} ({1:X8})", updatedMethod.newReturnType.FullName, updatedMethod.newReturnType.MetadataToken.ToInt32()); + Log.v("ret: {0} ({1:X8})", Utils.removeNewlines(updatedMethod.newReturnType.FullName), updatedMethod.newReturnType.MetadataToken.ToInt32()); for (int i = 0; i < updatedMethod.newArgTypes.Length; i++) { var updatedArg = updatedMethod.newArgTypes[i]; if (updatedArg == null) continue; - Log.v("arg {0}: {1} ({2:X8})", i, updatedArg.FullName, updatedArg.MetadataToken.ToInt32()); + Log.v("arg {0}: {1} ({2:X8})", i, Utils.removeNewlines(updatedArg.FullName), updatedArg.MetadataToken.ToInt32()); } Log.deIndent(); } diff --git a/de4dot.code/renamer/Renamer.cs b/de4dot.code/renamer/Renamer.cs index 75326491..e51f2cd1 100644 --- a/de4dot.code/renamer/Renamer.cs +++ b/de4dot.code/renamer/Renamer.cs @@ -104,7 +104,7 @@ namespace de4dot.code.renamer { if (method.MethodDefinition.Name != overrideMethod.Name) continue; Log.v("Removed useless override from method {0} ({1:X8}), override: {2:X8}", - method.MethodDefinition, + Utils.removeNewlines(method.MethodDefinition), method.MethodDefinition.MetadataToken.ToInt32(), overrideMethod.MetadataToken.ToInt32()); overrides.RemoveAt(i); @@ -154,7 +154,7 @@ namespace de4dot.code.renamer { if (list.Count != maxClasses) continue; var ns = list[0].TypeDefinition.Namespace; - Log.v("Removing namespace: {0}", ns); + Log.v("Removing namespace: {0}", Utils.removeNewlines(ns)); foreach (var type in list) memberInfos.type(type).newNamespace = ""; } @@ -173,7 +173,7 @@ namespace de4dot.code.renamer { var typeDefinition = type.TypeDefinition; var info = memberInfos.type(type); - Log.v("Type: {0} ({1:X8})", typeDefinition.FullName, typeDefinition.MetadataToken.ToUInt32()); + Log.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDefinition.FullName), typeDefinition.MetadataToken.ToUInt32()); Log.indent(); renameGenericParams(type.GenericParams); @@ -181,13 +181,13 @@ namespace de4dot.code.renamer { if (RenameTypes && info.gotNewName()) { var old = typeDefinition.Name; typeDefinition.Name = info.newName; - Log.v("Name: {0} => {1}", old, typeDefinition.Name); + Log.v("Name: {0} => {1}", Utils.removeNewlines(old), typeDefinition.Name); } if (RenameNamespaces && info.newNamespace != null) { var old = typeDefinition.Namespace; typeDefinition.Namespace = info.newNamespace; - Log.v("Namespace: {0} => {1}", old, typeDefinition.Namespace); + Log.v("Namespace: {0} => {1}", Utils.removeNewlines(old), typeDefinition.Namespace); } Log.deIndent(); @@ -201,7 +201,7 @@ namespace de4dot.code.renamer { if (!info.gotNewName()) continue; param.GenericParameter.Name = info.newName; - Log.v("GenParam: {0} => {1}", info.oldFullName, param.GenericParameter.FullName); + Log.v("GenParam: {0} => {1}", Utils.removeNewlines(info.oldFullName), param.GenericParameter.FullName); } } @@ -220,7 +220,7 @@ namespace de4dot.code.renamer { void renameMembers(TypeDef type) { var info = memberInfos.type(type); - Log.v("Type: {0}", info.type.TypeDefinition.FullName); + Log.v("Type: {0}", Utils.removeNewlines(info.type.TypeDefinition.FullName)); Log.indent(); renameFields(info); @@ -239,7 +239,7 @@ namespace de4dot.code.renamer { if (!fieldInfo.gotNewName()) continue; fieldDef.FieldDefinition.Name = fieldInfo.newName; - Log.v("Field: {0} ({1:X8}) => {2}", fieldInfo.oldFullName, fieldDef.FieldDefinition.MetadataToken.ToUInt32(), fieldDef.FieldDefinition.FullName); + Log.v("Field: {0} ({1:X8}) => {2}", Utils.removeNewlines(fieldInfo.oldFullName), fieldDef.FieldDefinition.MetadataToken.ToUInt32(), fieldDef.FieldDefinition.FullName); } } @@ -251,7 +251,7 @@ namespace de4dot.code.renamer { if (!propInfo.gotNewName()) continue; propDef.PropertyDefinition.Name = propInfo.newName; - Log.v("Property: {0} ({1:X8}) => {2}", propInfo.oldFullName, propDef.PropertyDefinition.MetadataToken.ToUInt32(), propDef.PropertyDefinition.FullName); + Log.v("Property: {0} ({1:X8}) => {2}", Utils.removeNewlines(propInfo.oldFullName), propDef.PropertyDefinition.MetadataToken.ToUInt32(), propDef.PropertyDefinition.FullName); } } @@ -263,7 +263,7 @@ namespace de4dot.code.renamer { if (!eventInfo.gotNewName()) continue; eventDef.EventDefinition.Name = eventInfo.newName; - Log.v("Event: {0} ({1:X8}) => {2}", eventInfo.oldFullName, eventDef.EventDefinition.MetadataToken.ToUInt32(), eventDef.EventDefinition.FullName); + Log.v("Event: {0} ({1:X8}) => {2}", Utils.removeNewlines(eventInfo.oldFullName), eventDef.EventDefinition.MetadataToken.ToUInt32(), eventDef.EventDefinition.FullName); } } @@ -272,14 +272,14 @@ namespace de4dot.code.renamer { return; foreach (var methodDef in info.type.AllMethodsSorted) { var methodInfo = memberInfos.method(methodDef); - Log.v("Method {0} ({1:X8})", methodInfo.oldFullName, methodDef.MethodDefinition.MetadataToken.ToUInt32()); + Log.v("Method {0} ({1:X8})", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDefinition.MetadataToken.ToUInt32()); Log.indent(); renameGenericParams(methodDef.GenericParams); if (RenameMethods && methodInfo.gotNewName()) { methodDef.MethodDefinition.Name = methodInfo.newName; - Log.v("Name: {0} => {1}", methodInfo.oldFullName, methodDef.MethodDefinition.FullName); + Log.v("Name: {0} => {1}", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDefinition.FullName); } if (RenameMethodArgs) { @@ -288,7 +288,7 @@ namespace de4dot.code.renamer { if (!paramInfo.gotNewName()) continue; param.ParameterDefinition.Name = paramInfo.newName; - Log.v("Param ({0}/{1}): {2} => {3}", param.Index + 1, methodDef.ParamDefs.Count, paramInfo.oldName, paramInfo.newName); + Log.v("Param ({0}/{1}): {2} => {3}", param.Index + 1, methodDef.ParamDefs.Count, Utils.removeNewlines(paramInfo.oldName), paramInfo.newName); } } @@ -395,10 +395,10 @@ namespace de4dot.code.renamer { continue; if (s == "" || !module.ObfuscatedFile.RenameResourcesInCode) - Log.v("Possible resource name in code: '{0}' => '{1}' in method {2}", s, newName, method); + Log.v("Possible resource name in code: '{0}' => '{1}' in method {2}", Utils.removeNewlines(s), newName, Utils.removeNewlines(method)); else { instr.Operand = newName; - Log.v("Renamed resource string in code: '{0}' => '{1}' ({2})", s, newName, method); + Log.v("Renamed resource string in code: '{0}' => '{1}' ({2})", Utils.removeNewlines(s), newName, Utils.removeNewlines(method)); break; } } @@ -414,7 +414,7 @@ namespace de4dot.code.renamer { var newName = renameResourceString(s, info.oldFullName, info.type.TypeDefinition.FullName); if (newName != s) { resource.Name = newName; - Log.v("Renamed resource in resources: {0} => {1}", s, newName); + Log.v("Renamed resource in resources: {0} => {1}", Utils.removeNewlines(s), newName); break; } } @@ -601,9 +601,9 @@ namespace de4dot.code.renamer { if (propDef.GetMethod != null) return null; Log.v("Restoring property getter {0} ({1:X8}), Property: {2} ({3:X8})", - propMethod, + Utils.removeNewlines(propMethod), propMethod.MethodDefinition.MetadataToken.ToInt32(), - propDef.PropertyDefinition, + Utils.removeNewlines(propDef.PropertyDefinition), propDef.PropertyDefinition.MetadataToken.ToInt32()); propDef.PropertyDefinition.GetMethod = propMethod.MethodDefinition; propDef.GetMethod = propMethod; @@ -630,9 +630,9 @@ namespace de4dot.code.renamer { if (propDef.SetMethod != null) return null; Log.v("Restoring property setter {0} ({1:X8}), Property: {2} ({3:X8})", - propMethod, + Utils.removeNewlines(propMethod), propMethod.MethodDefinition.MetadataToken.ToInt32(), - propDef.PropertyDefinition, + Utils.removeNewlines(propDef.PropertyDefinition), propDef.PropertyDefinition.MetadataToken.ToInt32()); propDef.PropertyDefinition.SetMethod = propMethod.MethodDefinition; propDef.SetMethod = propMethod; @@ -650,7 +650,7 @@ namespace de4dot.code.renamer { propDef = ownerType.create(newProp); memberInfos.add(propDef); - Log.v("Restoring property: {0}", newProp); + Log.v("Restoring property: {0}", Utils.removeNewlines(newProp)); return propDef; } @@ -801,9 +801,9 @@ namespace de4dot.code.renamer { if (eventDef.AddMethod != null) return null; Log.v("Restoring event adder {0} ({1:X8}), Event: {2} ({3:X8})", - eventMethod, + Utils.removeNewlines(eventMethod), eventMethod.MethodDefinition.MetadataToken.ToInt32(), - eventDef.EventDefinition, + Utils.removeNewlines(eventDef.EventDefinition), eventDef.EventDefinition.MetadataToken.ToInt32()); eventDef.EventDefinition.AddMethod = eventMethod.MethodDefinition; eventDef.AddMethod = eventMethod; @@ -827,9 +827,9 @@ namespace de4dot.code.renamer { if (eventDef.RemoveMethod != null) return null; Log.v("Restoring event remover {0} ({1:X8}), Event: {2} ({3:X8})", - eventMethod, + Utils.removeNewlines(eventMethod), eventMethod.MethodDefinition.MetadataToken.ToInt32(), - eventDef.EventDefinition, + Utils.removeNewlines(eventDef.EventDefinition), eventDef.EventDefinition.MetadataToken.ToInt32()); eventDef.EventDefinition.RemoveMethod = eventMethod.MethodDefinition; eventDef.RemoveMethod = eventMethod; @@ -855,7 +855,7 @@ namespace de4dot.code.renamer { eventDef = ownerType.create(newEvent); memberInfos.add(eventDef); - Log.v("Restoring event: {0}", newEvent); + Log.v("Restoring event: {0}", Utils.removeNewlines(newEvent)); return eventDef; } @@ -1565,7 +1565,7 @@ namespace de4dot.code.renamer { continue; var methodDef = modules.resolve(entryPoint); if (methodDef == null) { - Log.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefinition.FullyQualifiedName, entryPoint)); + Log.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefinition.FullyQualifiedName, Utils.removeNewlines(entryPoint))); continue; } if (!methodDef.isStatic()) diff --git a/de4dot.code/renamer/asmmodules/Modules.cs b/de4dot.code/renamer/asmmodules/Modules.cs index 3084309e..f6126255 100644 --- a/de4dot.code/renamer/asmmodules/Modules.cs +++ b/de4dot.code/renamer/asmmodules/Modules.cs @@ -450,7 +450,7 @@ namespace de4dot.code.renamer.asmmodules { if (isAutoCreatedType(typeReference)) return null; Log.e("Could not resolve TypeReference {0} ({1:X8}) (from {2} -> {3})", - typeReference, + Utils.removeNewlines(typeReference), typeReference.MetadataToken.ToInt32(), typeReference.Module, typeReference.Scope); @@ -471,7 +471,7 @@ namespace de4dot.code.renamer.asmmodules { if (isAutoCreatedType(methodReference.DeclaringType)) return null; Log.e("Could not resolve MethodReference {0} ({1:X8}) (from {2} -> {3})", - methodReference, + Utils.removeNewlines(methodReference), methodReference.MetadataToken.ToInt32(), methodReference.DeclaringType.Module, methodReference.DeclaringType.Scope); @@ -492,7 +492,7 @@ namespace de4dot.code.renamer.asmmodules { if (isAutoCreatedType(fieldReference.DeclaringType)) return null; Log.e("Could not resolve FieldReference {0} ({1:X8}) (from {2} -> {3})", - fieldReference, + Utils.removeNewlines(fieldReference), fieldReference.MetadataToken.ToInt32(), fieldReference.DeclaringType.Module, fieldReference.DeclaringType.Scope); diff --git a/de4dot.code/renamer/asmmodules/TypeDef.cs b/de4dot.code/renamer/asmmodules/TypeDef.cs index b85d5dbd..5510aed6 100644 --- a/de4dot.code/renamer/asmmodules/TypeDef.cs +++ b/de4dot.code/renamer/asmmodules/TypeDef.cs @@ -609,9 +609,9 @@ namespace de4dot.code.renamer.asmmodules { continue; string errMsg = string.Format( "Could not find interface method {0} ({1:X8}). Type: {2} ({3:X8})", - pair.Key.MethodDefinition, + Utils.removeNewlines(pair.Key.MethodDefinition), pair.Key.MethodDefinition.MetadataToken.ToInt32(), - TypeDefinition, + Utils.removeNewlines(TypeDefinition), TypeDefinition.MetadataToken.ToInt32()); // Ignore if COM class if (!hasAttribute("System.Runtime.InteropServices.TypeLibTypeAttribute"))