protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Building VTables & identifier list..."); foreach (ModuleDef moduleDef in parameters.Targets.OfType <ModuleDef>()) { moduleDef.EnableTypeDefFindCache = true; } foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { ParseParameters(def, context, service, parameters); if (def is ModuleDef module) { foreach (var res in module.Resources) { service.AddReservedIdentifier(res.Name); } } else { service.StoreNames(def); } if (def is TypeDef typeDef) { service.GetVTables().GetVTable(typeDef); } context.CheckCancellation(); } context.Logger.Debug("Analyzing..."); RegisterRenamers(context, service); IList <IRenamer> renamers = service.Renamers; foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { Analyze(service, context, parameters, def, true); context.CheckCancellation(); } foreach (ModuleDef moduleDef in parameters.Targets.OfType <ModuleDef>()) { moduleDef.EnableTypeDefFindCache = false; moduleDef.ResetTypeDefFindCache(); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { RandomGenerator random = context.Registry.GetService <IRandomService>().GetRandomGenerator(ReferenceProxyProtection._FullId); var store = new RPStore { random = random }; foreach (MethodDef method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger)) { if (method.HasBody && method.Body.Instructions.Count > 0) { ProcessMethod(ParseParameters(method, context, parameters, store)); context.CheckCancellation(); } } RPContext ctx = ParseParameters(context.CurrentModule, context, parameters, store); if (store.mild != null) { store.mild.Finalize(ctx); } if (store.strong != null) { store.strong.Finalize(ctx); } }
protected override MarkerResult MarkProject(ConfuserProject proj, ConfuserContext context) { crossModuleAttrs = new Dictionary <string, Dictionary <Regex, List <ObfuscationAttributeInfo> > >(); this.context = context; project = proj; extModules = new List <byte[]>(); var modules = new List <Tuple <ProjectModule, ModuleDefMD> >(); foreach (ProjectModule module in proj) { ModuleDefMD modDef = module.Resolve(proj.BaseDirectory, context.Resolver.DefaultModuleContext); context.CheckCancellation(); context.Resolver.AddToCache(modDef); modules.Add(Tuple.Create(module, modDef)); } foreach (var module in modules) { context.Logger.InfoFormat("Loading '{0}'...", module.Item1.Path); MarkModule(module.Item2, module == modules[0]); // Packer parameters are stored in modules if (packer != null) { ProtectionParameters.GetParameters(context, module.Item2)[packer] = packerParams; } } return(new MarkerResult(modules.Select(module => module.Item2).ToList(), packer, extModules)); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } var typeService = context.Registry.GetService <TypeService>(); Debug.Assert(typeService != null, $"{nameof(typeService)} != null"); foreach (var target in parameters.Targets.WithProgress(context.Logger)) { switch (target) { case TypeDef typeDef: typeService.AddScannedItem(new ScannedType(typeDef)); break; case MethodDef methodDef: var scramblePublic = parameters.GetParameter(context, methodDef, "scramblePublic", false); typeService.AddScannedItem(new ScannedMethod(typeService, methodDef, scramblePublic)); break; } context.CheckCancellation(); } }
private void PackModules(ConfuserContext context, CompressorContext compCtx, ModuleDef stubModule, ICompressionService comp, RandomGenerator random) { int maxLen = 0; var modules = new Dictionary <string, byte[]>(); for (int i = 0; i < context.OutputModules.Count; i++) { if (i == compCtx.ModuleIndex) { continue; } string fullName = context.Modules[i].Assembly.FullName; modules.Add(fullName, context.OutputModules[i]); int strLen = Encoding.UTF8.GetByteCount(fullName); if (strLen > maxLen) { maxLen = strLen; } } byte[] key = random.NextBytes(4 + maxLen); key[0] = (byte)(compCtx.EntryPointToken >> 0); key[1] = (byte)(compCtx.EntryPointToken >> 8); key[2] = (byte)(compCtx.EntryPointToken >> 16); key[3] = (byte)(compCtx.EntryPointToken >> 24); for (int i = 4; i < key.Length; i++) // no zero bytes { key[i] |= 1; } compCtx.KeySig = key; int moduleIndex = 0; foreach (var entry in modules) { byte[] name = Encoding.UTF8.GetBytes(entry.Key); for (int i = 0; i < name.Length; i++) { name[i] *= key[i + 4]; } uint state = 0x6fff61; foreach (byte chr in name) { state = state * 0x5e3f1f + chr; } byte[] encrypted = compCtx.Encrypt(comp, entry.Value, state, progress => { progress = (progress + moduleIndex) / modules.Count; context.Logger.Progress((int)(progress * 10000), 10000); }); context.CheckCancellation(); var resource = new EmbeddedResource(Convert.ToBase64String(name), encrypted, ManifestResourceAttributes.Private); stubModule.Resources.Add(resource); moduleIndex++; } context.Logger.EndProgress(); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var rewriter = new TypeRewriter(context); rewriter.ApplyGeterics(); foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { switch (def) { case MethodDef md: if (md.HasBody) { rewriter.Process(md); } break; case ModuleDef mod: rewriter.ImportCode(mod); break; } context.CheckCancellation(); } }
// Token: 0x06000006 RID: 6 RVA: 0x00003B84 File Offset: 0x00001D84 protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { NameService service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Building VTables & identifier list..."); foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { this.ParseParameters(def, context, service, parameters); if (def is ModuleDef) { ModuleDef module = (ModuleDef)def; using (IEnumerator <Resource> enumerator2 = module.Resources.GetEnumerator()) { while (enumerator2.MoveNext()) { Resource res = enumerator2.Current; service.SetOriginalName(res, res.Name); } goto IL_B1; } goto IL_9F; } goto IL_9F; IL_B1: if (def is TypeDef) { service.GetVTables().GetVTable((TypeDef)def); service.SetOriginalNamespace(def, ((TypeDef)def).Namespace); } context.CheckCancellation(); continue; IL_9F: service.SetOriginalName(def, def.Name); goto IL_B1; } context.Logger.Debug("Analyzing..."); this.RegisterRenamers(context, service); IList <IRenamer> arg_120_0 = service.Renamers; foreach (IDnlibDef def2 in parameters.Targets.WithProgress(context.Logger)) { this.Analyze(service, context, parameters, def2, true); context.CheckCancellation(); } }
protected override void Pack(ConfuserContext context, ProtectionParameters parameters) { var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey); if (ctx == null) { context.Logger.Error("No executable module!"); throw new ConfuserException(null); } ModuleDefMD originModule = context.Modules[ctx.ModuleIndex]; ctx.OriginModuleDef = originModule; var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef); if (ctx.CompatMode) { var assembly = new AssemblyDefUser(originModule.Assembly); assembly.Name += ".cr"; assembly.Modules.Add(stubModule); } else { ctx.Assembly.Modules.Insert(0, stubModule); ImportAssemblyTypeReferences(originModule, stubModule); } stubModule.Characteristics = originModule.Characteristics; stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags; stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion; stubModule.DllCharacteristics = originModule.DllCharacteristics; stubModule.EncBaseId = originModule.EncBaseId; stubModule.EncId = originModule.EncId; stubModule.Generation = originModule.Generation; stubModule.Kind = ctx.Kind; stubModule.Machine = originModule.Machine; stubModule.RuntimeVersion = originModule.RuntimeVersion; stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion; stubModule.Win32Resources = originModule.Win32Resources; InjectStub(context, ctx, parameters, stubModule); var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey); using (var ms = new MemoryStream()) { var options = new ModuleWriterOptions(stubModule) { StrongNameKey = snKey }; var injector = new KeyInjector(ctx); options.WriterEvent += injector.WriterEvent; stubModule.Write(ms, options); context.CheckCancellation(); ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, new StubProtection(ctx, originModule)); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } // First check if the type scrambler did anything that needs rewriting. // If that is not the case, we can skip this whole thing. var service = context.Registry.GetService <TypeService>(); Debug.Assert(service != null, $"{nameof(service)} != null"); if (!service.ScrambledAnything) { return; } var rewriter = new TypeRewriter(context); rewriter.ApplyGenerics(); // In this stage the references to the scrambled types need to be fixed. This needs to be done for all // methods in the assembly, because all methods may contain references to the scrambled types and methods. foreach (var def in context.CurrentModule.FindDefinitions().WithProgress(context.Logger)) { switch (def) { case MethodDef md: if (md.HasReturnType) { md.ReturnType = rewriter.UpdateSignature(md.ReturnType); } if (md.HasBody) { rewriter.ProcessBody(md); } break; case TypeDef td: foreach (var field in td.Fields) { field.FieldType = rewriter.UpdateSignature(field.FieldType); } break; } context.CheckCancellation(); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Building VTables & identifier list..."); foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { ParseParameters(def, context, service, parameters); if (def is ModuleDef) { var module = (ModuleDef)def; foreach (Resource res in module.Resources) { service.SetOriginalName(res, res.Name); } } else { service.SetOriginalName(def, def.Name); } if (def is TypeDef) { service.GetVTables().GetVTable((TypeDef)def); service.SetOriginalNamespace(def, ((TypeDef)def).Namespace); } context.CheckCancellation(); } context.Logger.Debug("Analyzing..."); RegisterRenamers(context, service); IList <IRenamer> renamers = service.Renamers; foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { Analyze(service, context, parameters, def, true); context.CheckCancellation(); } }
private void CreateGenericsForTypes(ConfuserContext context, IEnumerable <TypeDef> types) { TypeService service = context.Registry.GetService <TypeService>(); foreach (TypeDef type in types) { if (type.Module.EntryPoint.DeclaringType != type) { service.AddScannedItem(new ScannedType(type)); context.CheckCancellation(); } } }
public void OnWriterEvent(object sender, ModuleWriterListenerEventArgs e) { var writer = (ModuleWriter)sender; if (commitListener != null) { commitListener.OnWriterEvent(writer, e.WriterEvent); } if (e.WriterEvent == ModuleWriterEvent.MDBeginWriteMethodBodies && methods.ContainsKey(writer.Module)) { ctx.Logger.Debug("Virtualizing methods..."); vr.ProcessMethods(writer.Module, (num, total) => { ctx.Logger.Progress(num, total); ctx.CheckCancellation(); }); ctx.Logger.EndProgress(); foreach (var repl in refRepl) { vr.Runtime.Descriptor.Data.ReplaceReference(repl.Key, repl.Value); } commitListener = vr.CommitModule(ctx.CurrentModule, (num, total) => { ctx.Logger.Progress(num, total); ctx.CheckCancellation(); }); } else if (commitListener != null && e.WriterEvent == ModuleWriterEvent.End && vr.ExportDbgInfo) { var mapName = Path.ChangeExtension(writer.Module.Name, "map"); var mapPath = Path.GetFullPath(Path.Combine(ctx.OutputDirectory, mapName)); Directory.CreateDirectory(ctx.OutputDirectory); File.WriteAllBytes(mapPath, vr.Runtime.DebugInfo); } }
// Token: 0x0600022B RID: 555 RVA: 0x0001F198 File Offset: 0x0001D398 protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { NameService service = (NameService)context.Registry.GetService <INameService>(); foreach (IRenamer renamer in service.Renamers) { foreach (IDnlibDef def in parameters.Targets) { renamer.PostRename(context, service, parameters, def); } context.CheckCancellation(); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var disabledOpti = DisabledOptimization(context.CurrentModule); var random = context.Registry.GetService <IRandomService>().GetRandomGenerator(ControlFlowProtection._FullId); foreach (var method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger)) { if (method.HasBody && method.Body.Instructions.Count > 0) { ProcessMethod(method.Body, ParseParameters(method, context, parameters, random, disabledOpti)); context.CheckCancellation(); } } }
private void CreateGenericsForMethods(ConfuserContext context, IEnumerable <MethodDef> methods) { TypeService service = context.Registry.GetService <TypeService>(); foreach (MethodDef method in methods) { /* * context.Logger.DebugFormat("[{0}]", method.Name); * if (method.HasBody) { * foreach(var i in method.Body.Instructions) { * context.Logger.DebugFormat("{0} - {1} : {2}", i.OpCode, i?.Operand?.GetType().ToString() ?? "NULL", i.Operand); * } * }*/ if (method.Module.EntryPoint != method && !(method.HasOverrides || method.IsAbstract || method.IsConstructor || method.IsGetter)) { service.AddScannedItem(new ScannedMethod(service, method)); context.CheckCancellation(); } } }
void InjectStub(ConfuserContext context, CompressorContext compCtx, ProtectionParameters parameters, ModuleDef stubModule) { var rt = context.Registry.GetService <IRuntimeService>(); RandomGenerator random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Id); var comp = context.Registry.GetService <ICompressionService>(); var rtType = rt.GetRuntimeType(compCtx.CompatMode ? "Confuser.Runtime.CompressorCompat" : "Confuser.Runtime.Compressor"); IEnumerable <IDnlibDef> defs = InjectHelper.Inject(rtType, stubModule.GlobalType, stubModule); switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Dynamic)) { case Mode.Normal: compCtx.Deriver = new NormalDeriver(); break; case Mode.Dynamic: compCtx.Deriver = new DynamicDeriver(); break; default: throw new UnreachableException(); } compCtx.Deriver.Init(context, random); context.Logger.Debug("Encrypting modules..."); // Main MethodDef entryPoint = defs.OfType <MethodDef>().Single(method => method.Name == "Main"); stubModule.EntryPoint = entryPoint; if (compCtx.EntryPoint.HasAttribute("System.STAThreadAttribute")) { var attrType = stubModule.CorLibTypes.GetTypeRef("System", "STAThreadAttribute"); var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void); entryPoint.CustomAttributes.Add(new CustomAttribute( new MemberRefUser(stubModule, ".ctor", ctorSig, attrType))); } else if (compCtx.EntryPoint.HasAttribute("System.MTAThreadAttribute")) { var attrType = stubModule.CorLibTypes.GetTypeRef("System", "MTAThreadAttribute"); var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void); entryPoint.CustomAttributes.Add(new CustomAttribute( new MemberRefUser(stubModule, ".ctor", ctorSig, attrType))); } uint seed = random.NextUInt32(); compCtx.OriginModule = context.OutputModules[compCtx.ModuleIndex]; byte[] encryptedModule = compCtx.Encrypt(comp, compCtx.OriginModule, seed, progress => context.Logger.Progress((int)(progress * 10000), 10000)); context.Logger.EndProgress(); context.CheckCancellation(); compCtx.EncryptedModule = encryptedModule; MutationHelper.InjectKeys(entryPoint, new[] { 0, 1 }, new[] { encryptedModule.Length >> 2, (int)seed }); InjectData(stubModule, entryPoint, encryptedModule); // Decrypt MethodDef decrypter = defs.OfType <MethodDef>().Single(method => method.Name == "Decrypt"); decrypter.Body.SimplifyMacros(decrypter.Parameters); List <Instruction> instrs = decrypter.Body.Instructions.ToList(); for (int i = 0; i < instrs.Count; i++) { Instruction instr = instrs[i]; if (instr.OpCode == OpCodes.Call) { var method = (IMethod)instr.Operand; if (method.DeclaringType.Name == "Mutation" && method.Name == "Crypt") { Instruction ldDst = instrs[i - 2]; Instruction ldSrc = instrs[i - 1]; Debug.Assert(ldDst.OpCode == OpCodes.Ldloc && ldSrc.OpCode == OpCodes.Ldloc); instrs.RemoveAt(i); instrs.RemoveAt(i - 1); instrs.RemoveAt(i - 2); instrs.InsertRange(i - 2, compCtx.Deriver.EmitDerivation(decrypter, context, (Local)ldDst.Operand, (Local)ldSrc.Operand)); } else if (method.DeclaringType.Name == "Lzma" && method.Name == "Decompress") { MethodDef decomp = comp.GetRuntimeDecompressor(stubModule, member => { }); instr.Operand = decomp; } } } decrypter.Body.Instructions.Clear(); foreach (Instruction instr in instrs) { decrypter.Body.Instructions.Add(instr); } // Pack modules PackModules(context, compCtx, stubModule, comp, random); }
void ExtractConstants( ConfuserContext context, ProtectionParameters parameters, CEContext moduleCtx, Dictionary <object, List <Tuple <MethodDef, Instruction> > > ldc, Dictionary <byte[], List <Tuple <MethodDef, Instruction> > > ldInit) { foreach (MethodDef method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger)) { if (!method.HasBody) { continue; } moduleCtx.Elements = 0; string elements = parameters.GetParameter(context, method, "elements", "SI"); foreach (char elem in elements) { switch (elem) { case 'S': case 's': moduleCtx.Elements |= EncodeElements.Strings; break; case 'N': case 'n': moduleCtx.Elements |= EncodeElements.Numbers; break; case 'P': case 'p': moduleCtx.Elements |= EncodeElements.Primitive; break; case 'I': case 'i': moduleCtx.Elements |= EncodeElements.Initializers; break; } } if (moduleCtx.Elements == 0) { continue; } foreach (Instruction instr in method.Body.Instructions) { bool eligible = false; if (instr.OpCode == OpCodes.Ldstr && (moduleCtx.Elements & EncodeElements.Strings) != 0) { var operand = (string)instr.Operand; if (string.IsNullOrEmpty(operand) && (moduleCtx.Elements & EncodeElements.Primitive) == 0) { continue; } eligible = true; } else if (instr.OpCode == OpCodes.Call && (moduleCtx.Elements & EncodeElements.Initializers) != 0) { var operand = (IMethod)instr.Operand; if (operand.DeclaringType.DefinitionAssembly.IsCorLib() && operand.DeclaringType.Namespace == "System.Runtime.CompilerServices" && operand.DeclaringType.Name == "RuntimeHelpers" && operand.Name == "InitializeArray") { IList <Instruction> instrs = method.Body.Instructions; int i = instrs.IndexOf(instr); if (instrs[i - 1].OpCode != OpCodes.Ldtoken) { continue; } if (instrs[i - 2].OpCode != OpCodes.Dup) { continue; } if (instrs[i - 3].OpCode != OpCodes.Newarr) { continue; } if (instrs[i - 4].OpCode != OpCodes.Ldc_I4) { continue; } var dataField = instrs[i - 1].Operand as FieldDef; if (dataField == null) { continue; } if (!dataField.HasFieldRVA || dataField.InitialValue == null) { continue; } // Prevent array length from being encoded var arrLen = (int)instrs[i - 4].Operand; if (ldc.ContainsKey(arrLen)) { List <Tuple <MethodDef, Instruction> > list = ldc[arrLen]; list.RemoveWhere(entry => entry.Item2 == instrs[i - 4]); if (list.Count == 0) { ldc.Remove(arrLen); } } if (dataField.DeclaringType != null) { dataField.DeclaringType.Fields.Remove(dataField); } var value = new byte[dataField.InitialValue.Length + 4]; value[0] = (byte)(arrLen >> 0); value[1] = (byte)(arrLen >> 8); value[2] = (byte)(arrLen >> 16); value[3] = (byte)(arrLen >> 24); Buffer.BlockCopy(dataField.InitialValue, 0, value, 4, dataField.InitialValue.Length); ldInit.AddListEntry(value, Tuple.Create(method, instr)); } } else if ((moduleCtx.Elements & EncodeElements.Numbers) != 0) { if (instr.OpCode == OpCodes.Ldc_I4) { var operand = (int)instr.Operand; if ((operand >= -1 && operand <= 8) && (moduleCtx.Elements & EncodeElements.Primitive) == 0) { continue; } eligible = true; } else if (instr.OpCode == OpCodes.Ldc_I8) { var operand = (long)instr.Operand; if ((operand >= -1 && operand <= 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0) { continue; } eligible = true; } else if (instr.OpCode == OpCodes.Ldc_R4) { var operand = (float)instr.Operand; if ((operand == -1 || operand == 0 || operand == 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0) { continue; } eligible = true; } else if (instr.OpCode == OpCodes.Ldc_R8) { var operand = (double)instr.Operand; if ((operand == -1 || operand == 0 || operand == 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0) { continue; } eligible = true; } } if (eligible) { ldc.AddListEntry(instr.Operand, Tuple.Create(method, instr)); } } context.CheckCancellation(); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var moduleCtx = context.Annotations.Get <CEContext>(context.CurrentModule, ConstantProtection.ContextKey); if (!parameters.Targets.Any() || moduleCtx == null) { return; } var ldc = new Dictionary <object, List <Tuple <MethodDef, Instruction> > >(); var ldInit = new Dictionary <byte[], List <Tuple <MethodDef, Instruction> > >(new ByteArrayComparer()); // Extract constants ExtractConstants(context, parameters, moduleCtx, ldc, ldInit); // Encode constants moduleCtx.ReferenceRepl = new Dictionary <MethodDef, List <Tuple <Instruction, uint, IMethod> > >(); moduleCtx.EncodedBuffer = new List <uint>(); foreach (var entry in ldInit.WithProgress(context.Logger)) // Ensure the array length haven't been encoded yet { EncodeInitializer(moduleCtx, entry.Key, entry.Value); context.CheckCancellation(); } foreach (var entry in ldc.WithProgress(context.Logger)) { if (entry.Key is string) { EncodeString(moduleCtx, (string)entry.Key, entry.Value); } else if (entry.Key is int) { EncodeConstant32(moduleCtx, (uint)(int)entry.Key, context.CurrentModule.CorLibTypes.Int32, entry.Value); } else if (entry.Key is long) { EncodeConstant64(moduleCtx, (uint)((long)entry.Key >> 32), (uint)(long)entry.Key, context.CurrentModule.CorLibTypes.Int64, entry.Value); } else if (entry.Key is float) { var t = new RTransform(); t.R4 = (float)entry.Key; EncodeConstant32(moduleCtx, t.Lo, context.CurrentModule.CorLibTypes.Single, entry.Value); } else if (entry.Key is double) { var t = new RTransform(); t.R8 = (double)entry.Key; EncodeConstant64(moduleCtx, t.Hi, t.Lo, context.CurrentModule.CorLibTypes.Double, entry.Value); } else { throw new UnreachableException(); } context.CheckCancellation(); } ReferenceReplacer.ReplaceReference(moduleCtx, parameters); // compress var encodedBuff = new byte[moduleCtx.EncodedBuffer.Count * 4]; int buffIndex = 0; foreach (uint dat in moduleCtx.EncodedBuffer) { encodedBuff[buffIndex++] = (byte)((dat >> 0) & 0xff); encodedBuff[buffIndex++] = (byte)((dat >> 8) & 0xff); encodedBuff[buffIndex++] = (byte)((dat >> 16) & 0xff); encodedBuff[buffIndex++] = (byte)((dat >> 24) & 0xff); } Debug.Assert(buffIndex == encodedBuff.Length); encodedBuff = context.Registry.GetService <ICompressionService>().Compress(encodedBuff); context.CheckCancellation(); uint compressedLen = (uint)(encodedBuff.Length + 3) / 4; compressedLen = (compressedLen + 0xfu) & ~0xfu; var compressedBuff = new uint[compressedLen]; Buffer.BlockCopy(encodedBuff, 0, compressedBuff, 0, encodedBuff.Length); Debug.Assert(compressedLen % 0x10 == 0); // encrypt uint keySeed = moduleCtx.Random.NextUInt32(); var key = new uint[0x10]; uint state = keySeed; for (int i = 0; i < 0x10; i++) { state ^= state >> 12; state ^= state << 25; state ^= state >> 27; key[i] = state; } var encryptedBuffer = new byte[compressedBuff.Length * 4]; buffIndex = 0; while (buffIndex < compressedBuff.Length) { uint[] enc = moduleCtx.ModeHandler.Encrypt(compressedBuff, buffIndex, key); for (int j = 0; j < 0x10; j++) { key[j] ^= compressedBuff[buffIndex + j]; } Buffer.BlockCopy(enc, 0, encryptedBuffer, buffIndex * 4, 0x40); buffIndex += 0x10; } Debug.Assert(buffIndex == compressedBuff.Length); moduleCtx.DataField.InitialValue = encryptedBuffer; moduleCtx.DataField.HasFieldRVA = true; moduleCtx.DataType.ClassLayout = new ClassLayoutUser(0, (uint)encryptedBuffer.Length); MutationHelper.InjectKeys(moduleCtx.InitMethod, new[] { 0, 1 }, new[] { encryptedBuffer.Length / 4, (int)keySeed }); MutationHelper.ReplacePlaceholder(moduleCtx.InitMethod, arg => { var repl = new List <Instruction>(); repl.AddRange(arg); repl.Add(Instruction.Create(OpCodes.Dup)); repl.Add(Instruction.Create(OpCodes.Ldtoken, moduleCtx.DataField)); repl.Add(Instruction.Create(OpCodes.Call, moduleCtx.Module.Import( typeof(RuntimeHelpers).GetMethod("InitializeArray")))); return(repl.ToArray()); }); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Renaming..."); foreach (IRenamer renamer in service.Renamers) { foreach (IDnlibDef def in parameters.Targets) { renamer.PreRename(context, service, parameters, def); } context.CheckCancellation(); } var targets = parameters.Targets.ToList(); service.GetRandom().Shuffle(targets); var pdbDocs = new HashSet <string>(); foreach (IDnlibDef def in targets.WithProgress(context.Logger)) { if (def is ModuleDef && parameters.GetParameter(context, def, "rickroll", false)) { RickRoller.CommenceRickroll(context, (ModuleDef)def); } bool canRename = service.CanRename(def); RenameMode mode = service.GetRenameMode(def); if (def is MethodDef) { var method = (MethodDef)def; if ((canRename || method.IsConstructor) && parameters.GetParameter(context, def, "renameArgs", true)) { foreach (ParamDef param in ((MethodDef)def).ParamDefs) { param.Name = null; } } if (parameters.GetParameter(context, def, "renPdb", false) && method.HasBody) { foreach (var instr in method.Body.Instructions) { if (instr.SequencePoint != null && !pdbDocs.Contains(instr.SequencePoint.Document.Url)) { instr.SequencePoint.Document.Url = service.ObfuscateName(instr.SequencePoint.Document.Url, mode); pdbDocs.Add(instr.SequencePoint.Document.Url); } } foreach (var local in method.Body.Variables) { if (!string.IsNullOrEmpty(local.Name)) { local.Name = service.ObfuscateName(local.Name, mode); } } method.Body.Scope = null; } } if (!canRename) { continue; } IList <INameReference> references = service.GetReferences(def); bool cancel = false; foreach (INameReference refer in references) { cancel |= refer.ShouldCancelRename(); if (cancel) { break; } } if (cancel) { continue; } if (def is TypeDef) { var typeDef = (TypeDef)def; if (parameters.GetParameter(context, def, "flatten", true)) { typeDef.Name = service.ObfuscateName(typeDef.FullName, mode); typeDef.Namespace = ""; } else { typeDef.Namespace = service.ObfuscateName(typeDef.Namespace, mode); typeDef.Name = service.ObfuscateName(typeDef.Name, mode); } foreach (var param in typeDef.GenericParameters) { param.Name = ((char)(param.Number + 1)).ToString(); } } else if (def is MethodDef) { foreach (var param in ((MethodDef)def).GenericParameters) { param.Name = ((char)(param.Number + 1)).ToString(); } def.Name = service.ObfuscateName(def.Name, mode); } else { def.Name = service.ObfuscateName(def.Name, mode); } foreach (INameReference refer in references.ToList()) { if (!refer.UpdateNameReference(context, service)) { context.Logger.ErrorFormat("Failed to update name reference on '{0}'.", def); throw new ConfuserException(null); } } context.CheckCancellation(); } }
// Token: 0x060002A7 RID: 679 RVA: 0x00020498 File Offset: 0x0001E698 protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { NameService service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Renaming..."); foreach (IRenamer renamer in service.Renamers) { foreach (IDnlibDef def in parameters.Targets) { renamer.PreRename(context, service, parameters, def); } context.CheckCancellation(); } HashSet <string> pdbDocs = new HashSet <string>(); foreach (IDnlibDef def2 in parameters.Targets.WithProgress(context.Logger)) { if (def2 is ModuleDef && parameters.GetParameter <bool>(context, def2, "rickroll", true)) { RickRoller.CommenceRickroll(context, (ModuleDef)def2); } bool canRename = service.CanRename(def2); RenameMode mode = service.GetRenameMode(def2); if (def2 is MethodDef) { MethodDef method = (MethodDef)def2; if (canRename && parameters.GetParameter <bool>(context, def2, "renameArgs", true)) { foreach (ParamDef param in ((MethodDef)def2).ParamDefs) { param.Name = null; } } if (parameters.GetParameter <bool>(context, def2, "renPdb", true) && method.HasBody) { foreach (Instruction instr in method.Body.Instructions) { if (instr.SequencePoint != null && !pdbDocs.Contains(instr.SequencePoint.Document.Url)) { instr.SequencePoint.Document.Url = service.ObfuscateName(instr.SequencePoint.Document.Url, mode); pdbDocs.Add(instr.SequencePoint.Document.Url); } } foreach (Local local in method.Body.Variables) { if (!string.IsNullOrEmpty(local.Name)) { local.Name = service.ObfuscateName(local.Name, mode); } } method.Body.Scope = null; } } if (canRename) { IList <INameReference> references = service.GetReferences(def2); bool cancel = false; foreach (INameReference refer in references) { cancel |= refer.ShouldCancelRename(); if (cancel) { break; } } if (!cancel) { if (def2 is TypeDef) { TypeDef typeDef = (TypeDef)def2; if (parameters.GetParameter <bool>(context, def2, "flatten", true)) { typeDef.Name = service.ObfuscateName(typeDef.FullName, mode); typeDef.Namespace = ""; } else { typeDef.Namespace = service.ObfuscateName(typeDef.Namespace, mode); typeDef.Name = service.ObfuscateName(typeDef.Name, mode); } using (IEnumerator <GenericParam> enumerator8 = typeDef.GenericParameters.GetEnumerator()) { while (enumerator8.MoveNext()) { GenericParam param2 = enumerator8.Current; param2.Name = ((char)(param2.Number + 1)).ToString(); } goto IL_455; } goto IL_3B6; } goto IL_3B6; IL_455: foreach (INameReference refer2 in references.ToList <INameReference>()) { if (!refer2.UpdateNameReference(context, service)) { context.Logger.ErrorFormat("Failed to update name reference on '{0}'.", new object[] { def2 }); throw new ConfuserException(null); } } context.CheckCancellation(); continue; IL_3B6: if (def2 is MethodDef) { foreach (GenericParam param3 in ((MethodDef)def2).GenericParameters) { param3.Name = ((char)(param3.Number + 1)).ToString(); } def2.Name = service.ObfuscateName(def2.Name, mode); goto IL_455; } def2.Name = service.ObfuscateName(def2.Name, mode); goto IL_455; } } } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { context.Logger.Log("Initializing DarksVM"); foreach (ModuleDefMD module in context.Modules) { context.Logger.LogFormat("Protecting '{0}' with DarksVM...", module.Name); } var random = context.Registry.GetService <IRandomService>(); var refProxy = context.Registry.GetService <IReferenceProxyService>(); var nameSrv = context.Registry.GetService <INameService>(); var seed = random.GetRandomGenerator(Parent.FullId).NextInt32(); string rtName = null; bool dbg = false, stackwalk = false; ModuleDef merge = null; foreach (var module in context.Modules) { if (rtName == null) { rtName = parameters.GetParameter <string>(context, module, "rtName"); } if (dbg == false) { dbg = parameters.GetParameter <bool>(context, module, "dbgInfo"); } if (stackwalk == false) { stackwalk = parameters.GetParameter <bool>(context, module, "stackwalk"); } merge = module; rtName = "Virtualization"; } rtName = rtName ?? "KoiVM.Runtime--test"; ModuleDefMD rtModule; var resStream = typeof(Virtualizer).Assembly.GetManifestResourceStream("KoiVM.Runtime.dll"); if (resStream != null) { rtModule = ModuleDefMD.Load(resStream, context.Resolver.DefaultModuleContext); } else { var rtPath = Path.Combine(koiDir, "KoiVM.Runtime.dll"); rtModule = ModuleDefMD.Load(rtPath, context.Resolver.DefaultModuleContext); } rtModule.Assembly.Name = rtName; rtModule.Name = rtName + ".dll"; var vr = new Virtualizer(seed, context.Project.Debug); vr.ExportDbgInfo = dbg; vr.DoStackWalk = stackwalk; vr.Initialize(rtModule); context.Annotations.Set(context, Fish.VirtualizerKey, vr); context.Annotations.Set(context, Fish.MergeKey, merge); if (merge != null) { var types = new List <TypeDef>(vr.RuntimeModule.GetTypes()); types.Remove(vr.RuntimeModule.GlobalType); vr.CommitRuntime(merge); foreach (var type in types) { foreach (var def in type.FindDefinitions()) { if (def is TypeDef && def != type) // nested type { continue; } nameSrv.SetCanRename(def, false); ProtectionParameters.SetParameters(context, def, new ProtectionSettings()); } } } else { vr.CommitRuntime(merge); } var ctor = typeof(InternalsVisibleToAttribute).GetConstructor(new[] { typeof(string) }); foreach (ModuleDef module in context.Modules) { var methods = new HashSet <MethodDef>(); foreach (var type in module.GetTypes()) { foreach (var method in type.Methods) { if (ProtectionParameters.GetParameters(context, method).ContainsKey(Parent)) { methods.Add(method); } } } if (methods.Count > 0) { var ca = new CustomAttribute((ICustomAttributeType)module.Import(ctor)); ca.ConstructorArguments.Add(new CAArgument(module.CorLibTypes.String, vr.RuntimeModule.Assembly.Name.String)); module.Assembly.CustomAttributes.Add(ca); } foreach (var entry in new Scanner(module, methods).Scan().WithProgress(context.Logger)) { if (entry.Item2) { context.Annotations.Set(entry.Item1, Fish.ExportKey, Fish.ExportKey); } else { refProxy.ExcludeTarget(context, entry.Item1); } context.CheckCancellation(); } } }
void CreateSection(ModuleWriterBase writer) { // move some PE parts to separate section to prevent it from being hashed var peSection = new PESection("", 0x60000020); bool moved = false; uint alignment; if (writer.StrongNameSignature != null) { alignment = writer.TextSection.Remove(writer.StrongNameSignature).Value; peSection.Add(writer.StrongNameSignature, alignment); moved = true; } var managedWriter = writer as ModuleWriter; if (managedWriter != null) { if (managedWriter.ImportAddressTable != null) { alignment = writer.TextSection.Remove(managedWriter.ImportAddressTable).Value; peSection.Add(managedWriter.ImportAddressTable, alignment); moved = true; } if (managedWriter.StartupStub != null) { alignment = writer.TextSection.Remove(managedWriter.StartupStub).Value; peSection.Add(managedWriter.StartupStub, alignment); moved = true; } } if (moved) { writer.Sections.Add(peSection); } // create section var nameBuffer = new byte[8]; nameBuffer[0] = (byte)(name1 >> 0); nameBuffer[1] = (byte)(name1 >> 8); nameBuffer[2] = (byte)(name1 >> 16); nameBuffer[3] = (byte)(name1 >> 24); nameBuffer[4] = (byte)(name2 >> 0); nameBuffer[5] = (byte)(name2 >> 8); nameBuffer[6] = (byte)(name2 >> 16); nameBuffer[7] = (byte)(name2 >> 24); var newSection = new PESection(Encoding.ASCII.GetString(nameBuffer), 0xE0000040); writer.Sections.Insert(random.NextInt32(writer.Sections.Count), newSection); // random padding at beginning to prevent revealing hash key newSection.Add(new ByteArrayChunk(random.NextBytes(0x10)), 0x10); // create index var bodyIndex = new JITBodyIndex(methods.Select(method => writer.MetaData.GetToken(method).Raw)); newSection.Add(bodyIndex, 0x10); // save methods foreach (MethodDef method in methods.WithProgress(context.Logger)) { if (!method.HasBody) { continue; } MDToken token = writer.MetaData.GetToken(method); var jitBody = new JITMethodBody(); var bodyWriter = new JITMethodBodyWriter(writer.MetaData, method.Body, jitBody, random.NextUInt32(), writer.MetaData.KeepOldMaxStack || method.Body.KeepOldMaxStack); bodyWriter.Write(); jitBody.Serialize(token.Raw, key, fieldLayout); bodyIndex.Add(token.Raw, jitBody); method.Body = NopBody; writer.MetaData.TablesHeap.MethodTable[token.Rid].ImplFlags |= (ushort)MethodImplAttributes.NoInlining; context.CheckCancellation(); } bodyIndex.PopulateSection(newSection); // padding to prevent bad size due to shift division newSection.Add(new ByteArrayChunk(new byte[4]), 4); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Renaming..."); foreach (var renamer in service.Renamers) { foreach (var def in parameters.Targets) { renamer.PreRename(context, service, parameters, def); } context.CheckCancellation(); } var targets = parameters.Targets.ToList(); service.GetRandom().Shuffle(targets); var pdbDocs = new HashSet <string>(); foreach (var def in GetTargetsWithDelay(targets, context, service).WithProgress(targets.Count, context.Logger)) { if (def is ModuleDef moduleDef && parameters.GetParameter(context, moduleDef, "rickroll", false)) { RickRoller.CommenceRickroll(context, moduleDef); } bool canRename = service.CanRename(def); var mode = service.GetRenameMode(def); if (def is MethodDef method) { if ((canRename || method.IsConstructor) && parameters.GetParameter(context, method, "renameArgs", true)) { foreach (var param in method.ParamDefs) { param.Name = null; } } if (parameters.GetParameter(context, method, "renPdb", false) && method.HasBody) { foreach (var instr in method.Body.Instructions) { if (instr.SequencePoint != null && !pdbDocs.Contains(instr.SequencePoint.Document.Url)) { instr.SequencePoint.Document.Url = service.ObfuscateName(instr.SequencePoint.Document.Url, mode); pdbDocs.Add(instr.SequencePoint.Document.Url); } } foreach (var local in method.Body.Variables) { if (!string.IsNullOrEmpty(local.Name)) { local.Name = service.ObfuscateName(local.Name, mode); } } if (method.Body.HasPdbMethod) { method.Body.PdbMethod.Scope = new PdbScope(); } } } if (!canRename) { continue; } service.SetIsRenamed(def); var references = service.GetReferences(def); bool cancel = references.Any(r => r.ShouldCancelRename); if (cancel) { continue; } if (def is TypeDef typeDef) { if (parameters.GetParameter(context, typeDef, "flatten", true)) { typeDef.Namespace = ""; } else { var nsFormat = parameters.GetParameter(context, typeDef, "nsFormat", "{0}"); typeDef.Namespace = service.ObfuscateName(nsFormat, typeDef.Namespace, mode); } typeDef.Name = service.ObfuscateName(typeDef, mode); RenameGenericParameters(typeDef.GenericParameters); } else if (def is MethodDef methodDef) { methodDef.Name = service.ObfuscateName(methodDef, mode); RenameGenericParameters(methodDef.GenericParameters); } else { def.Name = service.ObfuscateName(def, mode); } int updatedReferences = -1; do { var oldUpdatedCount = updatedReferences; // This resolves the changed name references and counts how many were changed. var updatedReferenceList = references.Where(refer => refer.UpdateNameReference(context, service)).ToArray(); updatedReferences = updatedReferenceList.Length; if (updatedReferences == oldUpdatedCount) { var errorBuilder = new StringBuilder(); errorBuilder.AppendLine("Infinite loop detected while resolving name references."); errorBuilder.Append("Processed definition: ").AppendDescription(def, service).AppendLine(); errorBuilder.Append("Assembly: ").AppendLine(context.CurrentModule.FullName); errorBuilder.AppendLine("Faulty References:"); foreach (var reference in updatedReferenceList) { errorBuilder.Append(" - ").AppendLine(reference.ToString(service)); } context.Logger.Error(errorBuilder.ToString().Trim()); throw new ConfuserException(); } context.CheckCancellation(); } while (updatedReferences > 0); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var service = (NameService)context.Registry.GetService <INameService>(); context.Logger.Debug("Renaming..."); foreach (IRenamer renamer in service.Renamers) { foreach (IDnlibDef def in parameters.Targets) { renamer.PreRename(context, service, parameters, def); } context.CheckCancellation(); } foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { if (def is ModuleDef && parameters.GetParameter(context, def, "rickroll", false)) { RickRoller.CommenceRickroll(context, (ModuleDef)def); } bool canRename = service.CanRename(def); if (def is MethodDef) { if (canRename && parameters.GetParameter(context, def, "renameArgs", true)) { foreach (ParamDef param in ((MethodDef)def).ParamDefs) { param.Name = null; } } } if (!canRename && !parameters.GetParameter(context, def, "forceRen", false)) { continue; } RenameMode mode = service.GetRenameMode(def); IList <INameReference> references = service.GetReferences(def); bool cancel = false; foreach (INameReference refer in references) { cancel |= refer.ShouldCancelRename(); if (cancel) { break; } } if (cancel) { continue; } if (def is TypeDef) { var typeDef = (TypeDef)def; if (parameters.GetParameter(context, def, "flatten", true)) { typeDef.Name = service.ObfuscateName(typeDef.FullName, mode); typeDef.Namespace = ""; } else { typeDef.Namespace = service.ObfuscateName(typeDef.Namespace, mode); typeDef.Name = service.ObfuscateName(typeDef.Name, mode); } foreach (var param in typeDef.GenericParameters) { param.Name = ((char)(param.Number + 1)).ToString(); } } else if (def is MethodDef) { foreach (var param in ((MethodDef)def).GenericParameters) { param.Name = ((char)(param.Number + 1)).ToString(); } def.Name = service.ObfuscateName(def.Name, mode); } else { def.Name = service.ObfuscateName(def.Name, mode); } foreach (INameReference refer in references.ToList()) { if (!refer.UpdateNameReference(context, service)) { context.Logger.ErrorFormat("Failed to update name reference on '{0}'.", def); throw new ConfuserException(null); } } context.CheckCancellation(); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (!parameters.Targets.Any()) { return; } context.CurrentModuleWriterOptions.WriterEvent += InsertVMBodies; // ReSharper disable once PossibleInvalidCastExceptionInForeachLoop foreach (MethodDef method in parameters.Targets.WithProgress(context.Logger)) { if (!method.HasBody || method.DeclaringType.IsGlobalModuleType || method.Body.HasExceptionHandlers) { continue; } var module = method.Module; if (!Context.Bodies.ContainsKey(module)) { Context.Bodies.Add(module, new VMBody()); } var translated = Dispatcher.TranslateMethod(Context.Bodies[module], method); if (translated == null) { continue; } Context.Bodies[module].Translated.Add(method, translated); Context.Bodies[module].MethodToIndex.Add(method, Context.Bodies[module].Translated.Count - 1); context.CheckCancellation(); } foreach (var pair in Context.Bodies) { if (pair.Value.Translated.Count < 1) { continue; } var target = pair.Key.Import(Context.Entry); foreach (var translated in pair.Value.Translated.WithProgress(context.Logger)) { var method = translated.Key; method.Body = new CilBody { MaxStack = 1 }; var body = method.Body.Instructions; body.Add(OpCodes.Ldtoken.ToInstruction(method.DeclaringType)); body.Add(OpCodes.Ldc_I4.ToInstruction(pair.Value.MethodToIndex[method])); AddParameters(method); var genericType = method.ReturnType == method.Module.CorLibTypes.Void ? target.DeclaringType.ToTypeSig() : method.ReturnType; var sig = new MethodSpecUser((MemberRef)target, new GenericInstMethodSig(genericType)); body.Add(OpCodes.Call.ToInstruction(sig)); if (method.ReturnType == method.Module.CorLibTypes.Void) { body.Add(OpCodes.Pop.ToInstruction()); } body.Add(OpCodes.Ret.ToInstruction()); context.CheckCancellation(); } } Context.RuntimeModule.Dispose(); }
protected override void Pack(ConfuserContext context, ProtectionParameters parameters) { var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey); if (ctx == null) { context.Logger.Error("No executable module!"); throw new ConfuserException(null); } ModuleDefMD originModule = context.Modules[ctx.ModuleIndex]; ctx.OriginModuleDef = originModule; var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef); if (ctx.CompatMode) { var assembly = new AssemblyDefUser(originModule.Assembly); assembly.Name += ".cr"; assembly.Modules.Add(stubModule); var targetFramework = originModule.Assembly.CustomAttributes.FirstOrDefault(ca => ca.TypeFullName == "System.Runtime.Versioning.TargetFrameworkAttribute"); if (targetFramework != null) { var attrType = stubModule.CorLibTypes.GetTypeRef("System.Runtime.Versioning", "TargetFrameworkAttribute"); var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void, stubModule.CorLibTypes.String); assembly.CustomAttributes.Add(new CustomAttribute( new MemberRefUser(stubModule, ".ctor", ctorSig, attrType), new CAArgument[] { new CAArgument(stubModule.CorLibTypes.String, targetFramework.ConstructorArguments[0].Value) })); } } else { ctx.Assembly.Modules.Insert(0, stubModule); ImportAssemblyTypeReferences(originModule, stubModule); } stubModule.Characteristics = originModule.Characteristics; stubModule.Context = originModule.Context; stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags; stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion; stubModule.DllCharacteristics = originModule.DllCharacteristics; stubModule.EncBaseId = originModule.EncBaseId; stubModule.EncId = originModule.EncId; stubModule.Generation = originModule.Generation; stubModule.Kind = ctx.Kind; stubModule.Machine = originModule.Machine; stubModule.RuntimeVersion = originModule.RuntimeVersion; stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion; stubModule.Win32Resources = originModule.Win32Resources; InjectStub(context, ctx, parameters, stubModule); var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey); var snPubKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNPubKey); var snDelaySig = context.Annotations.Get <bool>(originModule, Marker.SNDelaySig, false); var snSigKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNSigKey); var snPubSigKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNSigPubKey); using (var ms = new MemoryStream()) { var options = new ModuleWriterOptions(stubModule) { StrongNameKey = snKey, StrongNamePublicKey = snPubKey, DelaySign = snDelaySig }; var injector = new KeyInjector(ctx); options.WriterEvent += injector.WriterEvent; stubModule.Write(ms, options); context.CheckCancellation(); ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, snPubKey, snSigKey, snPubKey, snDelaySig, new StubProtection(ctx, originModule)); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var vr = context.Annotations.Get <Virtualizer>(context, Fish.VirtualizerKey); var marker = context.Registry.GetService <IMarkerService>(); var refProxy = context.Registry.GetService <IReferenceProxyService>(); var antiTamper = context.Registry.GetService <IAntiTamperService>(); var compression = context.Registry.GetService <ICompressionService>(); var methods = new HashSet <MethodDef>(parameters.Targets.OfType <MethodDef>()); var refRepl = new Dictionary <IMemberRef, IMemberRef>(); var oldType = context.CurrentModule.GlobalType; var newType = new TypeDefUser(oldType.Name); oldType.Namespace = "What_a_great_VM"; oldType.Name = "VM"; oldType.BaseType = context.CurrentModule.CorLibTypes.GetTypeRef("System", "Object"); context.CurrentModule.Types.Insert(0, newType); var old_cctor = oldType.FindOrCreateStaticConstructor(); var cctor = newType.FindOrCreateStaticConstructor(); old_cctor.Name = "Load"; old_cctor.IsRuntimeSpecialName = false; old_cctor.IsSpecialName = false; old_cctor.Access = MethodAttributes.PrivateScope; cctor.Body = new CilBody(true, new List <Instruction> { Instruction.Create(OpCodes.Call, old_cctor), Instruction.Create(OpCodes.Ret) }, new List <ExceptionHandler>(), new List <Local>()); marker.Mark(cctor, Parent); antiTamper.ExcludeMethod(context, cctor); for (var i = 0; i < oldType.Methods.Count; i++) { var nativeMethod = oldType.Methods[i]; if (nativeMethod.IsNative) { var methodStub = new MethodDefUser(nativeMethod.Name, nativeMethod.MethodSig.Clone()); methodStub.Attributes = MethodAttributes.Assembly | MethodAttributes.Static; methodStub.Body = new CilBody(); methodStub.Body.Instructions.Add(new Instruction(OpCodes.Jmp, nativeMethod)); methodStub.Body.Instructions.Add(new Instruction(OpCodes.Ret)); oldType.Methods[i] = methodStub; newType.Methods.Add(nativeMethod); refRepl[nativeMethod] = methodStub; marker.Mark(methodStub, Parent); antiTamper.ExcludeMethod(context, methodStub); } } compression.TryGetRuntimeDecompressor(context.CurrentModule, def => { if (def is MethodDef) { methods.Remove((MethodDef)def); } }); var toProcess = new Dictionary <ModuleDef, List <MethodDef> >(); foreach (var entry in new Scanner(context.CurrentModule, methods).Scan().WithProgress(context.Logger)) { var isExport = entry.Item2; isExport |= context.Annotations.Get <object>(entry.Item1, Fish.ExportKey) != null; isExport |= refProxy.IsTargeted(context, entry.Item1); if (!isExport) { antiTamper.ExcludeMethod(context, entry.Item1); } vr.AddMethod(entry.Item1, isExport); toProcess.AddListEntry(entry.Item1.Module, entry.Item1); context.CheckCancellation(); } context.CurrentModuleWriterListener.OnWriterEvent += new Listener { ctx = context, vr = vr, methods = toProcess, refRepl = refRepl }.OnWriterEvent; }