public bool CanRename(object obj) { if (obj is IDnlibDef) { if (analyze == null) { analyze = context.Pipeline.FindPhase <AnalyzePhase>(); } var prot = (NameProtection)analyze.Parent; ProtectionSettings parameters = ProtectionParameters.GetParameters(context, (IDnlibDef)obj); if (parameters == null || !parameters.ContainsKey(prot)) { return(false); } return(context.Annotations.Get(obj, CanRenameKey, true)); } return(false); }
private void RerouteEntrypoint(ITypeService service, ConfuserContext context) { var originalEntry = context.CurrentModule.EntryPoint; if (originalEntry != null) { originalEntry.Name = "_start"; var param = originalEntry.Parameters.FirstOrDefault()?.Type; var newEntry = new MethodDefUser("Main", originalEntry.MethodSig, originalEntry.ImplAttributes, originalEntry.Attributes); IMethod callSig = originalEntry; var scannedEntry = service.GetScannedItem(originalEntry); if (scannedEntry != null) { callSig = new MethodSpecUser(originalEntry, new GenericInstMethodSig(scannedEntry.GenericCallTypes.ToArray())); } newEntry.Body = new dnlib.DotNet.Emit.CilBody(false, new Instruction[] { Instruction.Create(param == null ? OpCodes.Nop : OpCodes.Ldarg_0), Instruction.Create(OpCodes.Call, callSig), Instruction.Create(OpCodes.Ret), }, new ExceptionHandler[0], new LocalList()); originalEntry.DeclaringType.Methods.Add(newEntry); context.CurrentModule.EntryPoint = newEntry; ProtectionParameters.SetParameters(context, newEntry, ProtectionParameters.GetParameters(context, originalEntry)); service.RewriteMethodInstructions(newEntry); } }
void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, CEContext moduleCtx) { var members = InjectHelper.Inject(rt.GetRuntimeType("Confuser.Runtime.Constant"), context.CurrentModule.GlobalType, context.CurrentModule); foreach (var member in members) { if (member.Name == "Get") { context.CurrentModule.GlobalType.Remove((MethodDef)member); continue; } if (member.Name == "b") { moduleCtx.BufferField = (FieldDef)member; } else if (member.Name == "Initialize") { moduleCtx.InitMethod = (MethodDef)member; } moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent); } ProtectionParameters.GetParameters(context, moduleCtx.InitMethod).Remove(Parent); var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType")) { Layout = TypeAttributes.ExplicitLayout, Visibility = TypeAttributes.NestedPrivate, IsSealed = true }; moduleCtx.DataType = dataType; context.CurrentModule.GlobalType.NestedTypes.Add(dataType); moduleCtx.Name.MarkHelper(dataType, moduleCtx.Marker, (Protection)Parent); moduleCtx.DataField = new FieldDefUser(moduleCtx.Name.RandomName(), new FieldSig(dataType.ToTypeSig())) { IsStatic = true, Access = FieldAttributes.CompilerControlled }; context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField); moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent); var decoder = rt.GetRuntimeType("Confuser.Runtime.Constant").FindMethod("Get"); moduleCtx.Decoders = new List <Tuple <MethodDef, DecoderDesc> >(); for (var i = 0; i < moduleCtx.DecoderCount; i++) { var decoderInst = InjectHelper.Inject(decoder, context.CurrentModule); for (var j = 0; j < decoderInst.Body.Instructions.Count; j++) { var instr = decoderInst.Body.Instructions[j]; var method = instr.Operand as IMethod; var field = instr.Operand as IField; if (instr.OpCode == OpCodes.Call && method.DeclaringType.Name == "Mutation" && method.Name == "Value") { decoderInst.Body.Instructions[j] = Instruction.Create(OpCodes.Sizeof, new GenericMVar(0).ToTypeDefOrRef()); } else if (instr.OpCode == OpCodes.Ldsfld && method.DeclaringType.Name == "Constant") { if (field.Name == "b") { instr.Operand = moduleCtx.BufferField; } else { throw new UnreachableException(); } } } context.CurrentModule.GlobalType.Methods.Add(decoderInst); moduleCtx.Name.MarkHelper(decoderInst, moduleCtx.Marker, (Protection)Parent); ProtectionParameters.GetParameters(context, decoderInst).Remove(Parent); var decoderDesc = new DecoderDesc { StringID = (byte)(moduleCtx.Random.NextByte() & 3) }; do { decoderDesc.NumberID = (byte)(moduleCtx.Random.NextByte() & 3); }while (decoderDesc.NumberID == decoderDesc.StringID); do { decoderDesc.InitializerID = (byte)(moduleCtx.Random.NextByte() & 3); }while (decoderDesc.InitializerID == decoderDesc.StringID || decoderDesc.InitializerID == decoderDesc.NumberID); MutationHelper.InjectKeys(decoderInst, new[] { 0, 1, 2 }, new int[] { decoderDesc.StringID, decoderDesc.NumberID, decoderDesc.InitializerID }); decoderDesc.Data = moduleCtx.ModeHandler.CreateDecoder(decoderInst, moduleCtx); moduleCtx.Decoders.Add(Tuple.Create(decoderInst, decoderDesc)); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (parameters.Targets.Any()) { var compression = context.Registry.GetService <ICompressionService>(); var name = context.Registry.GetService <INameService>(); var marker = context.Registry.GetService <IMarkerService>(); var rt = context.Registry.GetService <IRuntimeService>(); var moduleCtx = new CEContext { Protection = (ConstantProtection)Parent, Random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Parent.Id), Context = context, Module = context.CurrentModule, Marker = marker, DynCipher = context.Registry.GetService <IDynCipherService>(), Name = name }; // Extract parameters moduleCtx.Mode = parameters.GetParameter(context, context.CurrentModule, "mode", Mode.Normal); moduleCtx.DecoderCount = parameters.GetParameter(context, context.CurrentModule, "decoderCount", 5); switch (moduleCtx.Mode) { case Mode.Normal: moduleCtx.ModeHandler = new NormalMode(); break; case Mode.Dynamic: moduleCtx.ModeHandler = new DynamicMode(); break; case Mode.x86: moduleCtx.ModeHandler = new x86Mode(); if ((context.CurrentModule.Cor20HeaderFlags & ComImageFlags.ILOnly) != 0) { context.CurrentModuleWriterOptions.Cor20HeaderOptions.Flags &= ~ComImageFlags.ILOnly; } break; default: throw new UnreachableException(); } // Inject helpers var decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member => { name.MarkHelper(member, marker, (Protection)Parent); if (member is MethodDef) { ProtectionParameters.GetParameters(context, member).Remove(Parent); } }); InjectHelpers(context, compression, rt, moduleCtx); // Mutate codes MutateInitializer(moduleCtx, decomp); var cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod)); context.Annotations.Set(context.CurrentModule, ConstantProtection.ContextKey, moduleCtx); } }
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(); } } }
public void ExcludeMethod(ConfuserContext context, MethodDef method) { ProtectionParameters.GetParameters(context, method).Remove(this); }
/// <inheritdoc /> public bool IsMarked(IDnlibDef def) { return(ProtectionParameters.GetParameters(context, def) != null); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (parameters.Targets.Any()) { if (!UTF8String.IsNullOrEmpty(context.CurrentModule.Assembly.Culture)) { context.Logger.DebugFormat("Skipping resource encryption for satellite assembly '{0}'.", context.CurrentModule.Assembly.FullName); return; } var compression = context.Registry.GetService <ICompressionService>(); var name = context.Registry.GetService <INameService>(); var marker = context.Registry.GetService <IMarkerService>(); var rt = context.Registry.GetService <IRuntimeService>(); var moduleCtx = new REContext { Random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Parent.Id), Context = context, Module = context.CurrentModule, Marker = marker, DynCipher = context.Registry.GetService <IDynCipherService>(), Name = name }; // Extract parameters moduleCtx.Mode = parameters.GetParameter(context, context.CurrentModule, "mode", Mode.Normal); switch (moduleCtx.Mode) { case Mode.Normal: moduleCtx.ModeHandler = new NormalMode(); break; case Mode.Dynamic: moduleCtx.ModeHandler = new DynamicMode(); break; default: throw new UnreachableException(); } // Inject helpers var decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member => { name.MarkHelper(member, marker, (Protection)Parent); if (member is MethodDef) { ProtectionParameters.GetParameters(context, member).Remove(Parent); } }); InjectHelpers(context, compression, rt, moduleCtx); // Mutate codes MutateInitializer(moduleCtx, decomp); var cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod)); new MDPhase(moduleCtx).Hook(); } }
protected override void MarkMember(IDnlibDef member, ConfuserContext context) { ModuleDef module = ((IMemberRef)member).Module; ProtectionParameters.SetParameters(context, member, ProtectionParameters.GetParameters(context, module)); }