Пример #1
0
        static void printMethod(MethodPrinter methodPrinter, MethodDef method)
        {
            const LoggerEvent dumpLogLevel = LoggerEvent.Verbose;

            if (Logger.Instance.IgnoresEvent(dumpLogLevel))
            {
                return;
            }

            Logger.Instance.indent();

            Logger.v("Locals:");
            Logger.Instance.indent();
            for (int i = 0; i < method.Body.Variables.Count; i++)
            {
                Logger.v("#{0}: {1}", i, method.Body.Variables[i].Type);
            }
            Logger.Instance.deIndent();

            Logger.v("Code:");
            Logger.Instance.indent();
            methodPrinter.print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
            Logger.Instance.deIndent();

            Logger.Instance.deIndent();
        }
Пример #2
0
        static void printMethod(MethodPrinter methodPrinter, MethodDefinition method)
        {
            const Log.LogLevel dumpLogLevel = Log.LogLevel.verbose;

            if (!Log.isAtLeast(dumpLogLevel))
            {
                return;
            }

            Log.indent();

            Log.v("Locals:");
            Log.indent();
            for (int i = 0; i < method.Body.Variables.Count; i++)
            {
                Log.v("#{0}: {1}", i, method.Body.Variables[i].VariableType);
            }
            Log.deIndent();

            Log.v("Code:");
            Log.indent();
            methodPrinter.print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
            Log.deIndent();

            Log.deIndent();
        }
Пример #3
0
        static void printMethod(MethodPrinter methodPrinter, MethodDefinition method)
        {
            const Log.LogLevel dumpLogLevel = Log.LogLevel.verbose;
            if (!Log.isAtLeast(dumpLogLevel))
                return;

            Log.indent();

            Log.v("Locals:");
            Log.indent();
            for (int i = 0; i < method.Body.Variables.Count; i++)
                Log.v("#{0}: {1}", i, method.Body.Variables[i].VariableType);
            Log.deIndent();

            Log.v("Code:");
            Log.indent();
            methodPrinter.print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
            Log.deIndent();

            Log.deIndent();
        }
Пример #4
0
        void deobfuscateMethods()
        {
            if (savedMethodBodies != null) {
                savedMethodBodies.restoreAll();
                savedMethodBodies = null;
            }
            deob.DeobfuscatedFile = null;

            Log.v("Deobfuscating methods");
            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.indent();

                if (hasNonEmptyBody(method)) {
                    var blocks = new Blocks(method);
                    int numRemovedLocals = 0;
                    int oldNumInstructions = method.Body.Instructions.Count;

                    deob.deobfuscateMethodBegin(blocks);
                    if (options.ControlFlowDeobfuscation) {
                        cflowDeobfuscator.init(blocks);
                        cflowDeobfuscator.deobfuscate();
                    }

                    if (deob.deobfuscateOther(blocks) && options.ControlFlowDeobfuscation)
                        cflowDeobfuscator.deobfuscate();

                    if (options.ControlFlowDeobfuscation) {
                        numRemovedLocals = blocks.optimizeLocals();
                        blocks.repartitionBlocks();
                    }

                    deobfuscateStrings(blocks);
                    deob.deobfuscateMethodEnd(blocks);

                    IList<Instruction> allInstructions;
                    IList<ExceptionHandler> allExceptionHandlers;
                    blocks.getCode(out allInstructions, out allExceptionHandlers);
                    DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);

                    if (numRemovedLocals > 0)
                        Log.v("Removed {0} unused local(s)", numRemovedLocals);
                    int numRemovedInstructions = oldNumInstructions - method.Body.Instructions.Count;
                    if (numRemovedInstructions > 0)
                        Log.v("Removed {0} dead instruction(s)", numRemovedInstructions);

                    const Log.LogLevel dumpLogLevel = Log.LogLevel.veryverbose;
                    if (Log.isAtLeast(dumpLogLevel)) {
                        Log.log(dumpLogLevel, "Deobfuscated code:");
                        Log.indent();
                        methodPrinter.print(dumpLogLevel, method, allInstructions, allExceptionHandlers);
                        Log.deIndent();
                    }
                }

                removeNoInliningAttribute(method);

                Log.deIndent();
            }
        }