From 211d1b67f634d4546ca51a278c0218cb5f63c642 Mon Sep 17 00:00:00 2001 From: de4dot Date: Sat, 19 Jan 2013 13:03:57 +0100 Subject: [PATCH] Use standard .NET naming convention --- AssemblyData/AssemblyResolver.cs | 32 +- AssemblyData/AssemblyServer.cs | 8 +- AssemblyData/AssemblyService.cs | 62 +- AssemblyData/DelegateStringDecrypter.cs | 10 +- AssemblyData/EmuStringDecrypter.cs | 14 +- AssemblyData/IAssemblyService.cs | 20 +- AssemblyData/IStringDecrypter.cs | 4 +- AssemblyData/SimpleData.cs | 4 +- AssemblyData/Utils.cs | 12 +- .../methodsrewriter/AssemblyResolver.cs | 44 +- AssemblyData/methodsrewriter/CodeGenerator.cs | 94 +- .../methodsrewriter/IMethodsRewriter.cs | 2 +- AssemblyData/methodsrewriter/MMethod.cs | 2 +- AssemblyData/methodsrewriter/MModule.cs | 42 +- AssemblyData/methodsrewriter/MType.cs | 30 +- .../methodsrewriter/MethodsRewriter.cs | 184 ++-- AssemblyData/methodsrewriter/Resolver.cs | 82 +- AssemblyData/methodsrewriter/ResolverUtils.cs | 28 +- .../methodsrewriter/TypeInstanceResolver.cs | 24 +- AssemblyData/methodsrewriter/TypeResolver.cs | 10 +- AssemblyServer-CLR20-x64/Program.cs | 2 +- AssemblyServer-CLR20/Program.cs | 2 +- AssemblyServer-CLR40-x64/Program.cs | 2 +- AssemblyServer-CLR40/Program.cs | 2 +- AssemblyServer-x64/Program.cs | 2 +- AssemblyServer/Program.cs | 2 +- blocks/Block.cs | 142 +-- blocks/Blocks.cs | 54 +- blocks/BlocksSorter.cs | 80 +- blocks/CodeGenerator.cs | 96 +- blocks/DeadBlocksRemover.cs | 48 +- blocks/DotNetUtils.cs | 194 ++-- blocks/DumpedMethods.cs | 10 +- blocks/ForwardScanOrder.cs | 48 +- blocks/GenericArgsSubstitutor.cs | 104 +- blocks/Instr.cs | 42 +- blocks/InstructionListParser.cs | 110 +- blocks/MemberDefDict.cs | 174 ++-- blocks/ScopeBlock.cs | 102 +- blocks/TryBlock.cs | 2 +- blocks/Utils.cs | 6 +- blocks/cflow/BlockCflowDeobfuscator.cs | 28 +- blocks/cflow/BlockDeobfuscator.cs | 12 +- blocks/cflow/BlocksCflowDeobfuscator.cs | 72 +- blocks/cflow/BranchEmulator.cs | 242 ++--- blocks/cflow/CachedCflowDeobfuscator.cs | 26 +- blocks/cflow/CflowDeobfuscator.cs | 20 +- blocks/cflow/CflowUtils.cs | 4 +- blocks/cflow/ConstantsFolder.cs | 28 +- blocks/cflow/DeadCodeRemover.cs | 34 +- blocks/cflow/DeadStoreRemover.cs | 22 +- blocks/cflow/DupBlockDeobfuscator.cs | 10 +- blocks/cflow/IBlocksDeobfuscator.cs | 4 +- blocks/cflow/ICflowDeobfuscator.cs | 2 +- blocks/cflow/InstructionEmulator.cs | 942 +++++++++--------- blocks/cflow/Int32Value.cs | 226 ++--- blocks/cflow/Int64Value.cs | 204 ++-- blocks/cflow/MethodCallInliner.cs | 20 +- blocks/cflow/MethodCallInlinerBase.cs | 92 +- blocks/cflow/StLdlocFixer.cs | 12 +- blocks/cflow/SwitchCflowDeobfuscator.cs | 216 ++-- blocks/cflow/Value.cs | 16 +- blocks/cflow/ValueStack.cs | 26 +- de4dot-x64/Program.cs | 2 +- de4dot.code/AssemblyClient/AssemblyClient.cs | 12 +- .../AssemblyClient/AssemblyClientFactory.cs | 14 +- de4dot.code/AssemblyClient/IAssemblyClient.cs | 4 +- .../AssemblyClient/IAssemblyServerLoader.cs | 4 +- .../AssemblyClient/IpcAssemblyServerLoader.cs | 16 +- .../NewAppDomainAssemblyServerLoader.cs | 12 +- .../NewProcessAssemblyServerLoader.cs | 6 +- .../SameAppDomainAssemblyServerLoader.cs | 4 +- de4dot.code/AssemblyModule.cs | 20 +- de4dot.code/AssemblyResolver.cs | 8 +- de4dot.code/DeobfuscatorContext.cs | 22 +- de4dot.code/DumpedMethodsRestorer.cs | 10 +- de4dot.code/IDeobfuscatorContext.cs | 14 +- de4dot.code/IObfuscatedFile.cs | 12 +- de4dot.code/Logger.cs | 18 +- de4dot.code/MethodPrinter.cs | 98 +- de4dot.code/MethodReturnValueInliner.cs | 92 +- de4dot.code/NameRegexes.cs | 10 +- de4dot.code/ObfuscatedFile.cs | 278 +++--- de4dot.code/Option.cs | 18 +- de4dot.code/StringInliner.cs | 38 +- de4dot.code/Utils.cs | 62 +- .../Agile_NET/CliSecureRtType.cs | 72 +- .../deobfuscators/Agile_NET/CsBlowfish.cs | 4 +- .../deobfuscators/Agile_NET/Deobfuscator.cs | 156 +-- .../Agile_NET/MethodsDecrypter.cs | 256 ++--- .../deobfuscators/Agile_NET/ProxyCallFixer.cs | 12 +- .../Agile_NET/ResourceDecrypter.cs | 36 +- .../Agile_NET/StackFrameHelper.cs | 6 +- .../Agile_NET/StringDecrypter.cs | 12 +- .../vm/CilOperandInstructionRestorer.cs | 18 +- .../deobfuscators/Agile_NET/vm/Csvm.cs | 58 +- .../Agile_NET/vm/CsvmDataReader.cs | 2 +- .../Agile_NET/vm/CsvmToCilMethodConverter.cs | 94 +- .../deobfuscators/Agile_NET/vm/FieldsInfo.cs | 18 +- .../Agile_NET/vm/OpCodeHandler.cs | 40 +- .../Agile_NET/vm/UnknownHandlerInfo.cs | 32 +- .../Agile_NET/vm/VmOpCodeHandlerDetector.cs | 54 +- de4dot.code/deobfuscators/ArrayFinder.cs | 60 +- .../Babel_NET/AssemblyResolver.cs | 22 +- .../Babel_NET/BabelMethodCallInliner.cs | 50 +- .../deobfuscators/Babel_NET/BabelUtils.cs | 40 +- .../Babel_NET/ConstantsDecrypter.cs | 64 +- .../deobfuscators/Babel_NET/Deobfuscator.cs | 162 +-- .../deobfuscators/Babel_NET/ImageReader.cs | 192 ++-- .../Babel_NET/InflaterCreator.cs | 36 +- .../Babel_NET/MemberReferenceConverter.cs | 48 +- .../Babel_NET/MethodBodyReader.cs | 42 +- .../Babel_NET/MethodReferenceReader.cs | 28 +- .../Babel_NET/MethodsDecrypter.cs | 64 +- .../deobfuscators/Babel_NET/ProxyCallFixer.cs | 32 +- .../Babel_NET/ResourceDecrypter.cs | 60 +- .../Babel_NET/ResourceResolver.cs | 30 +- .../Babel_NET/StringDecrypter.cs | 196 ++-- de4dot.code/deobfuscators/Blowfish.cs | 28 +- de4dot.code/deobfuscators/CRC32.cs | 2 +- .../deobfuscators/CodeFort/AssemblyData.cs | 122 +-- .../CodeFort/AssemblyDecrypter.cs | 92 +- .../CodeFort/CfMethodCallInliner.cs | 6 +- .../deobfuscators/CodeFort/Deobfuscator.cs | 88 +- .../deobfuscators/CodeFort/PasswordFinder.cs | 66 +- .../deobfuscators/CodeFort/ProxyCallFixer.cs | 34 +- .../deobfuscators/CodeFort/StringDecrypter.cs | 18 +- .../CodeVeil/AssemblyResolver.cs | 64 +- .../deobfuscators/CodeVeil/Deobfuscator.cs | 150 +-- .../CodeVeil/ErexResourceReader.cs | 18 +- .../CodeVeil/InvalidMethodsFinder.cs | 6 +- .../deobfuscators/CodeVeil/MainType.cs | 76 +- .../CodeVeil/MethodsDecrypter.cs | 68 +- .../deobfuscators/CodeVeil/ProxyCallFixer.cs | 72 +- .../CodeVeil/ResourceConverter.cs | 50 +- .../CodeVeil/ResourceDecrypter.cs | 102 +- .../deobfuscators/CodeVeil/ResourceReader.cs | 14 +- .../deobfuscators/CodeVeil/StringDecrypter.cs | 66 +- .../deobfuscators/CodeVeil/TamperDetection.cs | 42 +- .../CodeWall/AssemblyDecrypter.cs | 72 +- .../deobfuscators/CodeWall/Deobfuscator.cs | 96 +- .../deobfuscators/CodeWall/KeyGenerator.cs | 6 +- .../CodeWall/MethodsDecrypter.cs | 36 +- .../deobfuscators/CodeWall/StringDecrypter.cs | 82 +- de4dot.code/deobfuscators/ConstantsReader.cs | 84 +- .../CryptoObfuscator/AntiDebugger.cs | 42 +- .../CryptoObfuscator/AssemblyResolver.cs | 30 +- .../deobfuscators/CryptoObfuscator/CoUtils.cs | 10 +- .../CryptoObfuscator/ConstantsDecrypter.cs | 34 +- .../CryptoObfuscator/Deobfuscator.cs | 162 +-- .../CryptoObfuscator/MethodBodyReader.cs | 18 +- .../CryptoObfuscator/MethodsDecrypter.cs | 38 +- .../CryptoObfuscator/ProxyCallFixer.cs | 24 +- .../CryptoObfuscator/ResourceDecrypter.cs | 92 +- .../CryptoObfuscator/ResourceResolver.cs | 30 +- .../CryptoObfuscator/StringDecrypter.cs | 30 +- .../CryptoObfuscator/TamperDetection.cs | 62 +- .../DeepSea/ArrayBlockDeobfuscator.cs | 56 +- .../deobfuscators/DeepSea/ArrayBlockState.cs | 56 +- .../deobfuscators/DeepSea/AssemblyResolver.cs | 132 +-- .../deobfuscators/DeepSea/CastDeobfuscator.cs | 40 +- .../deobfuscators/DeepSea/Deobfuscator.cs | 134 +-- .../DeepSea/DsConstantsReader.cs | 4 +- .../DeepSea/DsInlinedMethodsFinder.cs | 4 +- .../DeepSea/DsMethodCallInliner.cs | 102 +- de4dot.code/deobfuscators/DeepSea/DsUtils.cs | 14 +- .../deobfuscators/DeepSea/FieldsRestorer.cs | 110 +- .../deobfuscators/DeepSea/ResolverBase.cs | 82 +- .../deobfuscators/DeepSea/ResourceResolver.cs | 70 +- .../deobfuscators/DeepSea/StringDecrypter.cs | 264 ++--- de4dot.code/deobfuscators/DeobUtils.cs | 82 +- de4dot.code/deobfuscators/DeobfuscatorBase.cs | 376 +++---- .../deobfuscators/DeobfuscatorInfoBase.cs | 12 +- .../deobfuscators/Dotfuscator/Deobfuscator.cs | 36 +- .../Dotfuscator/StringDecrypter.cs | 26 +- .../Eazfuscator_NET/AssemblyResolver.cs | 186 ++-- .../CodeCompilerMethodCallRestorer.cs | 50 +- .../Eazfuscator_NET/DecrypterType.cs | 124 +-- .../Eazfuscator_NET/Deobfuscator.cs | 106 +- .../deobfuscators/Eazfuscator_NET/Dynocode.cs | 70 +- .../Eazfuscator_NET/EfConstantsReader.cs | 10 +- .../deobfuscators/Eazfuscator_NET/EfUtils.cs | 8 +- .../ResourceMethodsRestorer.cs | 38 +- .../Eazfuscator_NET/ResourceResolver.cs | 44 +- .../Eazfuscator_NET/StringDecrypter.cs | 288 +++--- .../Eazfuscator_NET/VersionDetector.cs | 174 ++-- .../deobfuscators/ExceptionLoggerRemover.cs | 18 +- .../Goliath_NET/ArrayDecrypter.cs | 12 +- .../Goliath_NET/ArrayValueInliner.cs | 4 +- .../Goliath_NET/DecrypterBase.cs | 66 +- .../deobfuscators/Goliath_NET/Deobfuscator.cs | 146 +-- .../Goliath_NET/IntegerDecrypter.cs | 12 +- .../Goliath_NET/LocalsRestorer.cs | 28 +- .../Goliath_NET/LogicalExpressionFixer.cs | 4 +- .../Goliath_NET/ProxyCallFixer.cs | 22 +- .../Goliath_NET/StringDecrypter.cs | 18 +- .../Goliath_NET/StrongNameChecker.cs | 28 +- .../deobfuscators/IDeobfuscatedFile.cs | 6 +- de4dot.code/deobfuscators/IDeobfuscator.cs | 24 +- .../deobfuscators/IDeobfuscatorInfo.cs | 4 +- .../deobfuscators/ILProtector/Deobfuscator.cs | 32 +- .../deobfuscators/ILProtector/MainType.cs | 20 +- .../deobfuscators/ILProtector/MethodReader.cs | 58 +- .../ILProtector/MethodsDecrypter.cs | 100 +- .../deobfuscators/ISimpleDeobfuscator.cs | 6 +- .../deobfuscators/InitializedDataCreator.cs | 38 +- .../deobfuscators/InlinedMethodsFinder.cs | 8 +- .../deobfuscators/MPRESS/Deobfuscator.cs | 58 +- de4dot.code/deobfuscators/MPRESS/Lzmat.cs | 4 +- .../deobfuscators/MaxtoCode/CryptDecrypter.cs | 126 +-- .../deobfuscators/MaxtoCode/Decrypter6.cs | 60 +- .../deobfuscators/MaxtoCode/Deobfuscator.cs | 66 +- .../deobfuscators/MaxtoCode/MainType.cs | 36 +- de4dot.code/deobfuscators/MaxtoCode/McKey.cs | 10 +- .../MaxtoCode/MethodsDecrypter.cs | 312 +++--- .../deobfuscators/MaxtoCode/PeHeader.cs | 28 +- .../MaxtoCode/StringDecrypter.cs | 36 +- .../deobfuscators/MemberReferenceBuilder.cs | 46 +- de4dot.code/deobfuscators/MethodBodyParser.cs | 36 +- .../deobfuscators/MethodCallRestorerBase.cs | 66 +- de4dot.code/deobfuscators/MethodCollection.cs | 28 +- de4dot.code/deobfuscators/MethodStack.cs | 62 +- de4dot.code/deobfuscators/MethodsDecrypter.cs | 18 +- de4dot.code/deobfuscators/MyPEImage.cs | 78 +- .../deobfuscators/ProxyCallFixerBase.cs | 174 ++-- de4dot.code/deobfuscators/QuickLZ.cs | 40 +- .../deobfuscators/RandomNameChecker.cs | 70 +- .../deobfuscators/Rummage/Deobfuscator.cs | 36 +- .../deobfuscators/Rummage/StringDecrypter.cs | 116 +-- .../deobfuscators/Skater_NET/Deobfuscator.cs | 36 +- .../Skater_NET/EnumClassFinder.cs | 14 +- .../Skater_NET/StringDecrypter.cs | 76 +- .../SmartAssembly/AssemblyResolver.cs | 24 +- .../SmartAssembly/AssemblyResolverInfo.cs | 40 +- .../AutomatedErrorReportingFinder.cs | 16 +- .../SmartAssembly/Deobfuscator.cs | 228 ++--- .../SmartAssembly/MemoryManagerInfo.cs | 20 +- .../SmartAssembly/ProxyCallFixer.cs | 20 +- .../SmartAssembly/ResolverInfoBase.cs | 82 +- .../SmartAssembly/ResourceDecrypter.cs | 10 +- .../SmartAssembly/ResourceDecrypterInfo.cs | 14 +- .../SmartAssembly/ResourceResolver.cs | 8 +- .../SmartAssembly/ResourceResolverInfo.cs | 12 +- .../SmartAssembly/SimpleZipInfo.cs | 6 +- .../SmartAssembly/StringDecrypter.cs | 6 +- .../SmartAssembly/StringDecrypterInfo.cs | 100 +- .../SmartAssembly/StringEncoderClassFinder.cs | 66 +- .../SmartAssembly/TamperProtectionRemover.cs | 100 +- .../deobfuscators/Spices_Net/Deobfuscator.cs | 82 +- .../Spices_Net/QclzDecompressor.cs | 14 +- .../Spices_Net/ResourceNamesRestorer.cs | 52 +- .../Spices_Net/SpicesMethodCallInliner.cs | 82 +- .../Spices_Net/StringDecrypter.cs | 76 +- de4dot.code/deobfuscators/StringCounts.cs | 30 +- de4dot.code/deobfuscators/TypesRestorer.cs | 198 ++-- .../deobfuscators/Unknown/Deobfuscator.cs | 14 +- .../deobfuscators/UnusedMethodsFinder.cs | 14 +- de4dot.code/deobfuscators/ValueInlinerBase.cs | 50 +- .../deobfuscators/Xenocode/Deobfuscator.cs | 46 +- .../deobfuscators/Xenocode/StringDecrypter.cs | 6 +- .../dotNET_Reactor/v3/AntiStrongName.cs | 66 +- .../v3/ApplicationModeDecrypter.cs | 6 +- .../v3/ApplicationModeUnpacker.cs | 72 +- .../dotNET_Reactor/v3/AssemblyResolver.cs | 12 +- .../dotNET_Reactor/v3/DecryptMethod.cs | 14 +- .../dotNET_Reactor/v3/DecrypterType.cs | 62 +- .../dotNET_Reactor/v3/Deobfuscator.cs | 184 ++-- .../dotNET_Reactor/v3/LibAssemblyResolver.cs | 28 +- .../dotNET_Reactor/v3/MemoryPatcher.cs | 46 +- .../dotNET_Reactor/v3/NativeLibSaver.cs | 20 +- .../dotNET_Reactor/v4/AntiStrongname.cs | 56 +- .../dotNET_Reactor/v4/AssemblyResolver.cs | 66 +- .../dotNET_Reactor/v4/BooleanDecrypter.cs | 16 +- .../dotNET_Reactor/v4/Deobfuscator.cs | 306 +++--- .../dotNET_Reactor/v4/EmptyClass.cs | 18 +- .../dotNET_Reactor/v4/EncryptedResource.cs | 54 +- .../v4/MetadataTokenObfuscator.cs | 10 +- .../dotNET_Reactor/v4/MethodsDecrypter.cs | 78 +- .../dotNET_Reactor/v4/NativeFileDecrypter.cs | 2 +- .../dotNET_Reactor/v4/NativeImageUnpacker.cs | 38 +- .../dotNET_Reactor/v4/ProxyCallFixer.cs | 32 +- .../dotNET_Reactor/v4/ResourceResolver.cs | 42 +- .../dotNET_Reactor/v4/StringDecrypter.cs | 58 +- de4dot.code/renamer/DerivedFrom.cs | 10 +- de4dot.code/renamer/ExistingNames.cs | 24 +- de4dot.code/renamer/INameChecker.cs | 20 +- de4dot.code/renamer/MemberInfos.cs | 40 +- de4dot.code/renamer/NameCreators.cs | 52 +- de4dot.code/renamer/Renamer.cs | 748 +++++++------- de4dot.code/renamer/ResourceKeysRenamer.cs | 64 +- de4dot.code/renamer/ResourceRenamer.cs | 30 +- de4dot.code/renamer/TypeInfo.cs | 422 ++++---- de4dot.code/renamer/TypeNames.cs | 56 +- de4dot.code/renamer/TypeRenamerState.cs | 12 +- de4dot.code/renamer/VariableNameState.cs | 108 +- de4dot.code/renamer/asmmodules/EventDef.cs | 6 +- .../renamer/asmmodules/GenericParamDef.cs | 2 +- de4dot.code/renamer/asmmodules/IResolver.cs | 6 +- .../renamer/asmmodules/MemberRefFinder.cs | 398 ++++---- de4dot.code/renamer/asmmodules/MethodDef.cs | 10 +- .../renamer/asmmodules/MethodNameGroups.cs | 38 +- de4dot.code/renamer/asmmodules/Module.cs | 68 +- de4dot.code/renamer/asmmodules/Modules.cs | 152 +-- de4dot.code/renamer/asmmodules/PropertyDef.cs | 8 +- de4dot.code/renamer/asmmodules/RefDict.cs | 42 +- de4dot.code/renamer/asmmodules/TypeDef.cs | 296 +++--- de4dot.code/resources/BuiltInResourceData.cs | 2 +- de4dot.code/resources/IResourceData.cs | 2 +- de4dot.code/resources/ResourceDataCreator.cs | 78 +- de4dot.code/resources/ResourceElementSet.cs | 2 +- de4dot.code/resources/ResourceReader.cs | 58 +- de4dot.code/resources/ResourceWriter.cs | 40 +- de4dot.code/resources/UserResourceData.cs | 10 +- de4dot.cui/CommandLineParser.cs | 132 +-- de4dot.cui/FilesDeobfuscator.cs | 126 +-- de4dot.cui/Program.cs | 46 +- de4dot.mdecrypt/DynamicMethodsDecrypter.cs | 178 ++-- de4dot.mdecrypt/NativeCodeGenerator.cs | 34 +- de4dot/Program.cs | 2 +- 319 files changed, 10050 insertions(+), 10050 deletions(-) diff --git a/AssemblyData/AssemblyResolver.cs b/AssemblyData/AssemblyResolver.cs index 2af5f8fc..f2a85f23 100644 --- a/AssemblyData/AssemblyResolver.cs +++ b/AssemblyData/AssemblyResolver.cs @@ -30,17 +30,17 @@ namespace AssemblyData { List assemblySearchPaths = new List(); public AssemblyResolver() { - AppDomain.CurrentDomain.AssemblyResolve += assemblyResolve; + AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve; } - void addAssemblySearchPath(string path) { + void AddAssemblySearchPath(string path) { if (assemblySearchPathsDict.ContainsKey(path)) return; assemblySearchPathsDict[path] = true; assemblySearchPaths.Add(path); } - Assembly get(string assemblyFullName) { + Assembly Get(string assemblyFullName) { var asmName = new AssemblyName(assemblyFullName); Assembly assembly; @@ -53,8 +53,8 @@ namespace AssemblyData { } static string[] assemblyExtensions = new string[] { ".dll", ".exe" }; - Assembly assemblyResolve(object sender, ResolveEventArgs args) { - var assembly = get(args.Name); + Assembly AssemblyResolve(object sender, ResolveEventArgs args) { + var assembly = Get(args.Name); if (assembly != null) return assembly; @@ -65,8 +65,8 @@ namespace AssemblyData { var filename = Path.Combine(path, asmName.Name + ext); if (!new FileInfo(filename).Exists) continue; - addConfigFile(filename + ".config"); - return addAssembly(Assembly.LoadFile(filename)); + AddConfigFile(filename + ".config"); + return AddAssembly(Assembly.LoadFile(filename)); } catch (IOException) { } @@ -86,12 +86,12 @@ namespace AssemblyData { return null; } - public Assembly load(string filename) { - addConfigFile(filename + ".config"); - return addAssembly(loadFile(filename)); + public Assembly Load(string filename) { + AddConfigFile(filename + ".config"); + return AddAssembly(LoadFile(filename)); } - Assembly loadFile(string filename) { + Assembly LoadFile(string filename) { try { return Assembly.LoadFrom(filename); } @@ -101,16 +101,16 @@ namespace AssemblyData { } } - Assembly addAssembly(Assembly assembly) { + Assembly AddAssembly(Assembly assembly) { var asmName = assembly.GetName(); assemblies[asmName.FullName] = assembly; assemblies[asmName.Name] = assembly; return assembly; } - void addConfigFile(string configFilename) { - var dirName = Utils.getDirName(Utils.getFullPath(configFilename)); - addAssemblySearchPath(dirName); + void AddConfigFile(string configFilename) { + var dirName = Utils.GetDirName(Utils.GetFullPath(configFilename)); + AddAssemblySearchPath(dirName); try { using (var xmlStream = new FileStream(configFilename, FileMode.Open, FileAccess.Read, FileShare.Read)) { @@ -124,7 +124,7 @@ namespace AssemblyData { if (string.IsNullOrEmpty(privatePath)) continue; foreach (var path in privatePath.Split(';')) - addAssemblySearchPath(Path.Combine(dirName, path)); + AddAssemblySearchPath(Path.Combine(dirName, path)); } } } diff --git a/AssemblyData/AssemblyServer.cs b/AssemblyData/AssemblyServer.cs index 1c1d1c3a..44c9ce0b 100644 --- a/AssemblyData/AssemblyServer.cs +++ b/AssemblyData/AssemblyServer.cs @@ -26,19 +26,19 @@ using AssemblyData; namespace AssemblyServer { public static class Start { - public static int main(string[] args) { + public static int Main2(string[] args) { if (args.Length != 2) Environment.Exit(1); var channelName = args[0]; var uri = args[1]; var service = new AssemblyService(); - startServer(service, channelName, uri); - service.waitExit(); + StartServer(service, channelName, uri); + service.WaitExit(); return 0; } - static void startServer(AssemblyService service, string name, string uri) { + static void StartServer(AssemblyService service, string name, string uri) { var props = new Hashtable(); props["portName"] = name; var provider = new BinaryServerFormatterSinkProvider(); diff --git a/AssemblyData/AssemblyService.cs b/AssemblyData/AssemblyService.cs index befe6f35..7b691efc 100644 --- a/AssemblyData/AssemblyService.cs +++ b/AssemblyData/AssemblyService.cs @@ -33,14 +33,14 @@ namespace AssemblyData { AssemblyResolver assemblyResolver = new AssemblyResolver(); bool installCompileMethodCalled = false; - public void doNothing() { + public void DoNothing() { } - public void exit() { + public void Exit() { exitEvent.Set(); } - public void waitExit() { + public void WaitExit() { exitEvent.WaitOne(); } @@ -48,28 +48,28 @@ namespace AssemblyData { return null; } - void checkStringDecrypter() { + void CheckStringDecrypter() { if (stringDecrypter == null) throw new ApplicationException("setStringDecrypterType() hasn't been called yet."); } - void checkAssembly() { + void CheckAssembly() { if (assembly == null) throw new ApplicationException("loadAssembly() hasn't been called yet."); } - public void loadAssembly(string filename) { + public void LoadAssembly(string filename) { if (assembly != null) throw new ApplicationException("Only one assembly can be explicitly loaded"); try { - assembly = assemblyResolver.load(filename); + assembly = assemblyResolver.Load(filename); } catch (BadImageFormatException) { throw new ApplicationException(string.Format("Could not load assembly {0}. Maybe it's 32-bit or 64-bit only?", filename)); } } - public void setStringDecrypterType(StringDecrypterType type) { + public void SetStringDecrypterType(StringDecrypterType type) { if (stringDecrypter != null) throw new ApplicationException("StringDecrypterType already set"); @@ -87,25 +87,25 @@ namespace AssemblyData { } } - public int defineStringDecrypter(int methodToken) { - checkStringDecrypter(); - var methodInfo = findMethod(methodToken); + public int DefineStringDecrypter(int methodToken) { + CheckStringDecrypter(); + var methodInfo = FindMethod(methodToken); if (methodInfo == null) throw new ApplicationException(string.Format("Could not find method {0:X8}", methodToken)); if (methodInfo.ReturnType != typeof(string) && methodInfo.ReturnType != typeof(object)) throw new ApplicationException(string.Format("Method return type must be string or object: {0}", methodInfo)); - return stringDecrypter.defineStringDecrypter(methodInfo); + return stringDecrypter.DefineStringDecrypter(methodInfo); } - public object[] decryptStrings(int stringDecrypterMethod, object[] args, int callerToken) { - checkStringDecrypter(); - var caller = getCaller(callerToken); + public object[] DecryptStrings(int stringDecrypterMethod, object[] args, int callerToken) { + CheckStringDecrypter(); + var caller = GetCaller(callerToken); foreach (var arg in args) - SimpleData.unpack((object[])arg); - return SimpleData.pack(stringDecrypter.decryptStrings(stringDecrypterMethod, args, caller)); + SimpleData.Unpack((object[])arg); + return SimpleData.Pack(stringDecrypter.DecryptStrings(stringDecrypterMethod, args, caller)); } - MethodBase getCaller(int callerToken) { + MethodBase GetCaller(int callerToken) { try { return assembly.GetModules()[0].ResolveMethod(callerToken); } @@ -114,8 +114,8 @@ namespace AssemblyData { } } - MethodInfo findMethod(int methodToken) { - checkAssembly(); + MethodInfo FindMethod(int methodToken) { + CheckAssembly(); foreach (var module in assembly.GetModules()) { var method = module.ResolveMethod(methodToken) as MethodInfo; @@ -126,28 +126,28 @@ namespace AssemblyData { return null; } - public void installCompileMethod(DecryptMethodsInfo decryptMethodsInfo) { + public void InstallCompileMethod(DecryptMethodsInfo decryptMethodsInfo) { if (installCompileMethodCalled) throw new ApplicationException("installCompileMethod() has already been called"); installCompileMethodCalled = true; DynamicMethodsDecrypter.Instance.DecryptMethodsInfo = decryptMethodsInfo; - DynamicMethodsDecrypter.Instance.installCompileMethod(); + DynamicMethodsDecrypter.Instance.InstallCompileMethod(); } - public void loadObfuscator(string filename) { - loadAssembly(filename); + public void LoadObfuscator(string filename) { + LoadAssembly(filename); DynamicMethodsDecrypter.Instance.Module = assembly.ManifestModule; - DynamicMethodsDecrypter.Instance.loadObfuscator(); + DynamicMethodsDecrypter.Instance.LoadObfuscator(); } - public bool canDecryptMethods() { - checkAssembly(); - return DynamicMethodsDecrypter.Instance.canDecryptMethods(); + public bool CanDecryptMethods() { + CheckAssembly(); + return DynamicMethodsDecrypter.Instance.CanDecryptMethods(); } - public DumpedMethods decryptMethods() { - checkAssembly(); - return DynamicMethodsDecrypter.Instance.decryptMethods(); + public DumpedMethods DecryptMethods() { + CheckAssembly(); + return DynamicMethodsDecrypter.Instance.DecryptMethods(); } } } diff --git a/AssemblyData/DelegateStringDecrypter.cs b/AssemblyData/DelegateStringDecrypter.cs index 4dcfd29d..65996f5d 100644 --- a/AssemblyData/DelegateStringDecrypter.cs +++ b/AssemblyData/DelegateStringDecrypter.cs @@ -27,12 +27,12 @@ namespace AssemblyData { delegate string DecryptString(object[] args); List stringDecryptMethods = new List(); - public int defineStringDecrypter(MethodInfo method) { - stringDecryptMethods.Add(buildDynamicMethod(method)); + public int DefineStringDecrypter(MethodInfo method) { + stringDecryptMethods.Add(BuildDynamicMethod(method)); return stringDecryptMethods.Count - 1; } - public object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) { + public object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) { if (stringDecrypterMethod > stringDecryptMethods.Count) throw new ApplicationException("Invalid string decrypter method"); @@ -43,9 +43,9 @@ namespace AssemblyData { return rv; } - DecryptString buildDynamicMethod(MethodInfo method) { + DecryptString BuildDynamicMethod(MethodInfo method) { var dm = new DynamicMethod("", typeof(string), new Type[] { typeof(object[]) }, typeof(DelegateStringDecrypter), true); - Utils.addCallStringDecrypterMethodInstructions(method, dm.GetILGenerator()); + Utils.AddCallStringDecrypterMethodInstructions(method, dm.GetILGenerator()); return (DecryptString)dm.CreateDelegate(typeof(DecryptString)); } } diff --git a/AssemblyData/EmuStringDecrypter.cs b/AssemblyData/EmuStringDecrypter.cs index a9c4ff64..866873b2 100644 --- a/AssemblyData/EmuStringDecrypter.cs +++ b/AssemblyData/EmuStringDecrypter.cs @@ -36,26 +36,26 @@ namespace AssemblyData { } } - public int defineStringDecrypter(MethodInfo method) { + public int DefineStringDecrypter(MethodInfo method) { decryptInfos.Add(new DecryptInfo(method)); return decryptInfos.Count - 1; } - public object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) { + public object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) { var decryptInfo = decryptInfos[stringDecrypterMethod]; if (decryptInfo.decryptString == null) - decryptInfo.decryptString = createDecryptString(decryptInfo.method); + decryptInfo.decryptString = CreateDecryptString(decryptInfo.method); - methodsRewriter.setCaller(decryptInfo.decryptString, caller); + methodsRewriter.SetCaller(decryptInfo.decryptString, caller); var result = new object[args.Length]; for (int i = 0; i < args.Length; i++) result[i] = decryptInfo.decryptString((object[])args[i]); return result; } - RewrittenMethod createDecryptString(MethodInfo method) { - methodsRewriter.createMethod(method); - return methodsRewriter.createDelegate(method); + RewrittenMethod CreateDecryptString(MethodInfo method) { + methodsRewriter.CreateMethod(method); + return methodsRewriter.CreateDelegate(method); } } } diff --git a/AssemblyData/IAssemblyService.cs b/AssemblyData/IAssemblyService.cs index 70bb1023..2867531b 100644 --- a/AssemblyData/IAssemblyService.cs +++ b/AssemblyData/IAssemblyService.cs @@ -28,18 +28,18 @@ namespace AssemblyData { } public interface IAssemblyService { - void doNothing(); - void exit(); + void DoNothing(); + void Exit(); - void loadAssembly(string filename); + void LoadAssembly(string filename); - void setStringDecrypterType(StringDecrypterType type); - int defineStringDecrypter(int methodToken); - object[] decryptStrings(int stringDecrypterMethod, object[] args, int callerToken); + void SetStringDecrypterType(StringDecrypterType type); + int DefineStringDecrypter(int methodToken); + object[] DecryptStrings(int stringDecrypterMethod, object[] args, int callerToken); - void installCompileMethod(DecryptMethodsInfo decryptMethodsInfo); - void loadObfuscator(string filename); - bool canDecryptMethods(); - DumpedMethods decryptMethods(); + void InstallCompileMethod(DecryptMethodsInfo decryptMethodsInfo); + void LoadObfuscator(string filename); + bool CanDecryptMethods(); + DumpedMethods DecryptMethods(); } } diff --git a/AssemblyData/IStringDecrypter.cs b/AssemblyData/IStringDecrypter.cs index daf7bfcf..5798c563 100644 --- a/AssemblyData/IStringDecrypter.cs +++ b/AssemblyData/IStringDecrypter.cs @@ -21,7 +21,7 @@ using System.Reflection; namespace AssemblyData { interface IStringDecrypter { - int defineStringDecrypter(MethodInfo method); - object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller); + int DefineStringDecrypter(MethodInfo method); + object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller); } } diff --git a/AssemblyData/SimpleData.cs b/AssemblyData/SimpleData.cs index 2d2e7384..8f4147d1 100644 --- a/AssemblyData/SimpleData.cs +++ b/AssemblyData/SimpleData.cs @@ -51,7 +51,7 @@ namespace AssemblyData { } public static class SimpleData { - public static object[] pack(object[] args) { + public static object[] Pack(object[] args) { for (int i = 0; i < args.Length; i++) { var s = args[i] as string; if (s != null) @@ -60,7 +60,7 @@ namespace AssemblyData { return args; } - public static object[] unpack(object[] args) { + public static object[] Unpack(object[] args) { for (int i = 0; i < args.Length; i++) { var s = args[i] as MyString; if (s != null) diff --git a/AssemblyData/Utils.cs b/AssemblyData/Utils.cs index ec7458a4..470a14b8 100644 --- a/AssemblyData/Utils.cs +++ b/AssemblyData/Utils.cs @@ -68,11 +68,11 @@ namespace AssemblyData { static class Utils { static Random random = new Random(); - public static uint getRandomUint() { + public static uint GetRandomUint() { return (uint)(random.NextDouble() * uint.MaxValue); } - public static Type getDelegateType(Type returnType, Type[] args) { + public static Type GetDelegateType(Type returnType, Type[] args) { Type[] types; if (returnType == typeof(void)) { types = args; @@ -133,7 +133,7 @@ namespace AssemblyData { } } - public static string randomName(int min, int max) { + public static string RandomName(int min, int max) { int numChars = random.Next(min, max + 1); var sb = new StringBuilder(numChars); int numLower = 0; @@ -153,7 +153,7 @@ namespace AssemblyData { return sb.ToString(); } - public static void addCallStringDecrypterMethodInstructions(MethodInfo method, ILGenerator ilg) { + public static void AddCallStringDecrypterMethodInstructions(MethodInfo method, ILGenerator ilg) { var args = method.GetParameters(); for (int i = 0; i < args.Length; i++) { var arg = args[i].ParameterType; @@ -171,7 +171,7 @@ namespace AssemblyData { ilg.Emit(OpCodes.Ret); } - public static string getFullPath(string path) { + public static string GetFullPath(string path) { try { return Path.GetFullPath(path); } @@ -180,7 +180,7 @@ namespace AssemblyData { } } - public static string getDirName(string name) { + public static string GetDirName(string name) { return Path.GetDirectoryName(name); } } diff --git a/AssemblyData/methodsrewriter/AssemblyResolver.cs b/AssemblyData/methodsrewriter/AssemblyResolver.cs index 37688e78..37751599 100644 --- a/AssemblyData/methodsrewriter/AssemblyResolver.cs +++ b/AssemblyData/methodsrewriter/AssemblyResolver.cs @@ -35,10 +35,10 @@ namespace AssemblyData.methodsrewriter { public AssemblyResolver(string asmName) { assembly = Assembly.Load(new AssemblyName(asmName)); - initTypes(); + InitTypes(); } - void initTypes() { + void InitTypes() { foreach (var type in assembly.GetTypes()) { string key = (type.Namespace ?? "") + "." + type.Name; List list; @@ -48,7 +48,7 @@ namespace AssemblyData.methodsrewriter { } } - TypeResolver getTypeResolver(ITypeDefOrRef typeRef) { + TypeResolver GetTypeResolver(ITypeDefOrRef typeRef) { if (typeRef == null) return null; var scopeType = typeRef.ScopeType; @@ -65,30 +65,30 @@ namespace AssemblyData.methodsrewriter { } foreach (var resolver in list) { - if (ResolverUtils.compareTypes(resolver.type, scopeType)) + if (ResolverUtils.CompareTypes(resolver.type, scopeType)) return resolver; } return null; } - public FieldInfo resolve(IField fieldRef) { - var resolver = getTypeResolver(fieldRef.DeclaringType); + public FieldInfo Resolve(IField fieldRef) { + var resolver = GetTypeResolver(fieldRef.DeclaringType); if (resolver != null) - return resolver.resolve(fieldRef); - return resolveGlobalField(fieldRef); + return resolver.Resolve(fieldRef); + return ResolveGlobalField(fieldRef); } - FieldInfo resolveGlobalField(IField fieldRef) { - initGlobalFields(); + FieldInfo ResolveGlobalField(IField fieldRef) { + InitGlobalFields(); foreach (var globalField in globalFields) { - if (ResolverUtils.compareFields(globalField, fieldRef)) + if (ResolverUtils.CompareFields(globalField, fieldRef)) return globalField; } return null; } - void initGlobalFields() { + void InitGlobalFields() { if (globalFields != null) return; globalFields = new List(); @@ -100,23 +100,23 @@ namespace AssemblyData.methodsrewriter { } } - public MethodBase resolve(IMethod methodRef) { - var resolver = getTypeResolver(methodRef.DeclaringType); + public MethodBase Resolve(IMethod methodRef) { + var resolver = GetTypeResolver(methodRef.DeclaringType); if (resolver != null) - return resolver.resolve(methodRef); - return resolveGlobalMethod(methodRef); + return resolver.Resolve(methodRef); + return ResolveGlobalMethod(methodRef); } - MethodBase resolveGlobalMethod(IMethod methodRef) { - initGlobalMethods(); + MethodBase ResolveGlobalMethod(IMethod methodRef) { + InitGlobalMethods(); foreach (var globalMethod in globalMethods) { - if (ResolverUtils.compareMethods(globalMethod, methodRef)) + if (ResolverUtils.CompareMethods(globalMethod, methodRef)) return globalMethod; } return null; } - void initGlobalMethods() { + void InitGlobalMethods() { if (globalMethods != null) return; globalMethods = new List(); @@ -128,8 +128,8 @@ namespace AssemblyData.methodsrewriter { } } - public Type resolve(ITypeDefOrRef typeRef) { - var resolver = getTypeResolver(typeRef); + public Type Resolve(ITypeDefOrRef typeRef) { + var resolver = GetTypeResolver(typeRef); if (resolver != null) return resolver.type; diff --git a/AssemblyData/methodsrewriter/CodeGenerator.cs b/AssemblyData/methodsrewriter/CodeGenerator.cs index a567b415..e8c30846 100644 --- a/AssemblyData/methodsrewriter/CodeGenerator.cs +++ b/AssemblyData/methodsrewriter/CodeGenerator.cs @@ -81,14 +81,14 @@ namespace AssemblyData.methodsrewriter { this.methodName = methodName; } - public void setMethodInfo(MMethod methodInfo) { + public void SetMethodInfo(MMethod methodInfo) { this.methodInfo = methodInfo; - methodReturnType = ResolverUtils.getReturnType(methodInfo.methodBase); - methodParameters = getMethodParameterTypes(methodInfo.methodBase); - delegateType = Utils.getDelegateType(methodReturnType, methodParameters); + methodReturnType = ResolverUtils.GetReturnType(methodInfo.methodBase); + methodParameters = GetMethodParameterTypes(methodInfo.methodBase); + delegateType = Utils.GetDelegateType(methodReturnType, methodParameters); } - public Delegate generate(IList allInstructions, IList allExceptionHandlers) { + public Delegate Generate(IList allInstructions, IList allExceptionHandlers) { this.allInstructions = allInstructions; this.allExceptionHandlers = allExceptionHandlers; @@ -96,37 +96,37 @@ namespace AssemblyData.methodsrewriter { var lastInstr = allInstructions[allInstructions.Count - 1]; ilg = dm.GetILGenerator((int)lastInstr.Offset + lastInstr.GetSize()); - initInstrToIndex(); - initLocals(); - initLabels(); + InitInstrToIndex(); + InitLocals(); + InitLabels(); exceptionHandlersStack = new Stack(); for (int i = 0; i < allInstructions.Count; i++) { - updateExceptionHandlers(i); + UpdateExceptionHandlers(i); var instr = allInstructions[i]; ilg.MarkLabel(labels[i]); if (instr.Operand is Operand) - writeSpecialInstr(instr, (Operand)instr.Operand); + WriteSpecialInstr(instr, (Operand)instr.Operand); else - writeInstr(instr); + WriteInstr(instr); } - updateExceptionHandlers(-1); + UpdateExceptionHandlers(-1); return dm.CreateDelegate(delegateType); } - Instruction getExceptionInstruction(int instructionIndex) { + Instruction GetExceptionInstruction(int instructionIndex) { return instructionIndex < 0 ? null : allInstructions[instructionIndex]; } - void updateExceptionHandlers(int instructionIndex) { - var instr = getExceptionInstruction(instructionIndex); - updateExceptionHandlers(instr); - if (addTryStart(instr)) - updateExceptionHandlers(instr); + void UpdateExceptionHandlers(int instructionIndex) { + var instr = GetExceptionInstruction(instructionIndex); + UpdateExceptionHandlers(instr); + if (AddTryStart(instr)) + UpdateExceptionHandlers(instr); } - void updateExceptionHandlers(Instruction instr) { + void UpdateExceptionHandlers(Instruction instr) { while (exceptionHandlersStack.Count > 0) { var ex = exceptionHandlersStack.Peek(); if (ex.TryEnd == instr) { @@ -137,11 +137,11 @@ namespace AssemblyData.methodsrewriter { if (ex.HandlerType == ExceptionHandlerType.Finally) ilg.BeginFinallyBlock(); else - ilg.BeginCatchBlock(Resolver.getRtType(ex.CatchType)); + ilg.BeginCatchBlock(Resolver.GetRtType(ex.CatchType)); } if (ex.HandlerEnd == instr) { exceptionHandlersStack.Pop(); - if (exceptionHandlersStack.Count == 0 || !isSameTryBlock(ex, exceptionHandlersStack.Peek())) + if (exceptionHandlersStack.Count == 0 || !IsSameTryBlock(ex, exceptionHandlersStack.Peek())) ilg.EndExceptionBlock(); } else @@ -149,7 +149,7 @@ namespace AssemblyData.methodsrewriter { } } - bool addTryStart(Instruction instr) { + bool AddTryStart(Instruction instr) { var list = new List(); foreach (var ex in allExceptionHandlers) { if (ex.TryStart == instr) @@ -158,7 +158,7 @@ namespace AssemblyData.methodsrewriter { list.Reverse(); foreach (var ex in list) { - if (exceptionHandlersStack.Count == 0 || !isSameTryBlock(ex, exceptionHandlersStack.Peek())) + if (exceptionHandlersStack.Count == 0 || !IsSameTryBlock(ex, exceptionHandlersStack.Peek())) ilg.BeginExceptionBlock(); exceptionHandlersStack.Push(ex); } @@ -166,33 +166,33 @@ namespace AssemblyData.methodsrewriter { return list.Count > 0; } - static bool isSameTryBlock(ExceptionHandler ex1, ExceptionHandler ex2) { + static bool IsSameTryBlock(ExceptionHandler ex1, ExceptionHandler ex2) { return ex1.TryStart == ex2.TryStart && ex1.TryEnd == ex2.TryEnd; } - void initInstrToIndex() { + void InitInstrToIndex() { instrToIndex = new Dictionary(allInstructions.Count); for (int i = 0; i < allInstructions.Count; i++) instrToIndex[allInstructions[i]] = i; } - void initLocals() { + void InitLocals() { locals = new List(); foreach (var local in methodInfo.methodDef.Body.Variables) - locals.Add(ilg.DeclareLocal(Resolver.getRtType(local.Type), local.Type.RemoveModifiers().IsPinned)); + locals.Add(ilg.DeclareLocal(Resolver.GetRtType(local.Type), local.Type.RemoveModifiers().IsPinned)); tempObjLocal = ilg.DeclareLocal(typeof(object)); tempObjArrayLocal = ilg.DeclareLocal(typeof(object[])); } - void initLabels() { + void InitLabels() { labels = new List