internal void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, IDnlibDef def, bool runAnalyzer) { if (def is TypeDef) Analyze(service, context, parameters, (TypeDef)def); else if (def is MethodDef) Analyze(service, context, parameters, (MethodDef)def); else if (def is FieldDef) Analyze(service, context, parameters, (FieldDef)def); else if (def is PropertyDef) Analyze(service, context, parameters, (PropertyDef)def); else if (def is EventDef) Analyze(service, context, parameters, (EventDef)def); else if (def is ModuleDef) { var pass = parameters.GetParameter<string>(context, def, "password", null); if (pass != null) service.reversibleRenamer = new ReversibleRenamer(pass); service.SetCanRename(def, false); } if (!runAnalyzer || parameters.GetParameter(context, def, "forceRen", false)) return; foreach (IRenamer renamer in service.Renamers) renamer.Analyze(context, service, parameters, def); }
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, def); context.CheckCancellation(); } foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) { 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) 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); } } 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()) { 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 { 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 MethodDef decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member => { name.MarkHelper(member, marker); if (member is MethodDef) ProtectionParameters.GetParameters(context, member).Remove(Parent); }); InjectHelpers(context, compression, rt, moduleCtx); // Mutate codes MutateInitializer(moduleCtx, decomp); MethodDef 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) { if (context.Packer == null) return; if (context.Annotations.Get<CompressorContext>(context, Compressor.ContextKey) != null) return; var mainModule = parameters.GetParameter<string>(context, null, "main"); if (context.CurrentModule.Name == mainModule) { var ctx = new CompressorContext { ModuleIndex = context.CurrentModuleIndex, Assembly = context.CurrentModule.Assembly }; context.Annotations.Set(context, Compressor.ContextKey, ctx); ctx.ModuleName = context.CurrentModule.Name; context.CurrentModule.Name = "koi"; ctx.EntryPoint = context.CurrentModule.EntryPoint; context.CurrentModule.EntryPoint = null; ctx.Kind = context.CurrentModule.Kind; context.CurrentModule.Kind = ModuleKind.NetModule; context.CurrentModule.Assembly.Modules.Remove(context.CurrentModule); context.CurrentModuleWriterListener.OnWriterEvent += new ResourceRecorder(ctx, context.CurrentModule).OnWriterEvent; } }
public static void ReplaceReference(CEContext ctx, ProtectionParameters parameters) { foreach (var entry in ctx.ReferenceRepl) { if (parameters.GetParameter<bool>(ctx.Context, entry.Key, "cfg")) ReplaceCFG(entry.Key, entry.Value, ctx); else ReplaceNormal(entry.Key, entry.Value); } }
public void PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null || !parameters.GetParameter <bool>(context, def, "renXaml", true)) { return; } var wpfResInfo = context.Annotations.Get <Dictionary <string, Dictionary <string, BamlDocument> > >(module, BAMLKey); if (wpfResInfo == null) { return; } foreach (var res in wpfResInfo.Values) { foreach (var doc in res.Values) { var decodedName = HttpUtility.UrlDecode(doc.DocumentName); var encodedName = doc.DocumentName; if (bamlRefs.TryGetValue(decodedName, out var references)) { var decodedDirectory = decodedName.Substring(0, decodedName.LastIndexOf('/') + 1); var encodedDirectory = encodedName.Substring(0, encodedName.LastIndexOf('/') + 1); var fileName = service.RandomName(RenameMode.Letters).ToLowerInvariant(); if (decodedName.EndsWith(".BAML", StringComparison.OrdinalIgnoreCase)) { fileName += ".baml"; } else if (decodedName.EndsWith(".XAML", StringComparison.OrdinalIgnoreCase)) { fileName += ".xaml"; } string decodedNewName = decodedDirectory + fileName; string encodedNewName = encodedDirectory + fileName; context.Logger.Debug(String.Format("Preserving virtual paths. Replaced {0} with {1}", decodedName, decodedNewName)); bool renameOk = references.All(r => r.CanRename(decodedName, decodedNewName) || r.CanRename(encodedName, encodedNewName)); if (renameOk) { foreach (var bamlRef in references) { bamlRef.Rename(decodedName, decodedNewName); bamlRef.Rename(encodedName, encodedNewName); } doc.DocumentName = encodedNewName; } } } } }
void ParseParameters(IDnlibDef def, ConfuserContext context, NameService service, ProtectionParameters parameters) { var mode = parameters.GetParameter <RenameMode?>(context, def, "mode", null); if (mode != null) { service.SetRenameMode(def, mode.Value); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, PropertyDef property) { if (IsVisibleOutside(context, parameters, property.DeclaringType) && IsVisibleOutside(context, parameters, property)) { service.SetCanRename(property, false); } else if (property.IsRuntimeSpecialName) { service.SetCanRename(property, false); } else if (parameters.GetParameter(context, property, "forceRen", false)) { return; } /* * System.Xml.Serialization.XmlSerializer * * XmlSerializer by default serializes fields marked with [NonSerialized] * This is a work-around that causes all fields in a class marked [Serializable] * to _not_ be renamed, unless marked with [XmlIgnoreAttribute] * * If we have a way to detect which serializer method the code is going to use * for the class, or if Microsoft makes XmlSerializer respond to [NonSerialized] * we'll have a more accurate way to achieve this. */ else if (property.DeclaringType.IsSerializable) // && !field.IsNotSerialized) { service.SetCanRename(property, false); } else if (property.DeclaringType.IsSerializable && (property.CustomAttributes.IsDefined("XmlIgnore") || property.CustomAttributes.IsDefined("XmlIgnoreAttribute") || property.CustomAttributes.IsDefined("System.Xml.Serialization.XmlIgnore") || property.CustomAttributes.IsDefined("System.Xml.Serialization.XmlIgnoreAttribute") || property.CustomAttributes.IsDefined("T:System.Xml.Serialization.XmlIgnoreAttribute"))) // Can't seem to detect CustomAttribute { service.SetCanRename(property, true); } /* * End of XmlSerializer work-around */ else if (property.DeclaringType.Implements("System.ComponentModel.INotifyPropertyChanged")) { service.SetCanRename(property, false); } else if (property.DeclaringType.Name.String.Contains("AnonymousType")) { service.SetCanRename(property, false); } }
static RPContext ParseParameters(ModuleDef module, ConfuserContext context, ProtectionParameters parameters, RPStore store) { var ret = new RPContext(); ret.Depth = parameters.GetParameter(context, module, "depth", 3); ret.InitCount = parameters.GetParameter(context, module, "initCount", 0x10); ret.Random = store.random; ret.Module = module; ret.Context = context; ret.Marker = context.Registry.GetService <IMarkerService>(); ret.DynCipher = context.Registry.GetService <IDynCipherService>(); ret.Name = context.Registry.GetService <INameService>(); ret.Delegates = store.delegates; return(ret); }
public void PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null || !parameters.GetParameter <bool>(context, def, "renXaml", true)) { return; } var wpfResInfo = context.Annotations.Get <Dictionary <string, Dictionary <string, BamlDocument> > >(module, BAMLKey); if (wpfResInfo == null) { return; } foreach (var res in wpfResInfo.Values) { foreach (var doc in res.Values) { List <IBAMLReference> references; if (bamlRefs.TryGetValue(doc.DocumentName, out references)) { var newName = doc.DocumentName.ToUpperInvariant(); if (newName.EndsWith(".BAML")) { newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; } else if (newName.EndsWith(".XAML")) { newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; } bool renameOk = true; foreach (var bamlRef in references) { if (!bamlRef.CanRename(doc.DocumentName, newName)) { renameOk = false; break; } } if (renameOk) { foreach (var bamlRef in references) { bamlRef.Rename(doc.DocumentName, newName); } doc.DocumentName = newName; } } } } }
internal void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, IDnlibDef def, bool runAnalyzer) { if (def is TypeDef) { Analyze(service, context, parameters, (TypeDef)def); } else if (def is MethodDef) { Analyze(service, context, parameters, (MethodDef)def); } else if (def is FieldDef) { Analyze(service, context, parameters, (FieldDef)def); } else if (def is PropertyDef) { Analyze(service, context, parameters, (PropertyDef)def); } else if (def is EventDef) { Analyze(service, context, parameters, (EventDef)def); } else if (def is ModuleDef) { var pass = parameters.GetParameter <string>(context, def, "password", null); if (pass != null) { service.reversibleRenamer = new ReversibleRenamer(pass); } service.SetCanRename(def, false); } if (!runAnalyzer || parameters.GetParameter(context, def, "forceRen", false)) { return; } foreach (IRenamer renamer in service.Renamers) { renamer.Analyze(context, service, parameters, def); } }
static bool IsVisibleOutside(ConfuserContext context, ProtectionParameters parameters, IMemberDef def) { if (!(def is TypeDef type)) { type = def.DeclaringType; } bool?renPublic = parameters.GetParameter <bool?>(context, def, "renPublic", null); return(renPublic == null?type.IsVisibleOutside() : type.IsVisibleOutside(false) && !renPublic.Value); }
private void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, TypeDef type) { if (IsVisibleOutside(context, parameters, type)) { service.SetCanRename(type, false); } else if (type.IsRuntimeSpecialName || type.IsGlobalModuleType) { service.SetCanRename(type, false); } else if (type.FullName == "ModPhusedByAttribute") { // Courtesy service.SetCanRename(type, false); } if (type.CustomAttributes.Any(x => x.AttributeType.FullName == "System.Reflection.ObfuscationAttribute")) { var obfuscationAttr = type.CustomAttributes.First(x => x.AttributeType.FullName == "System.Reflection.ObfuscationAttribute"); var excludeParam = obfuscationAttr.NamedArguments.FirstOrDefault(x => x.Name == "Exclude"); if (excludeParam != null && ((bool)excludeParam.Value)) { // Obfuscation exclude, don't rename service.SetCanRename(type, false); // Also leave properties/methods alone foreach (var method in type.Methods) { service.SetCanRename(method, false); } // Also leave CONST fields alone foreach (var constField in type.Fields.Where(x => x.IsStatic && x.IsPublic)) { service.SetCanRename(constField, false); } // Remove attribute type.CustomAttributes.Remove(obfuscationAttr); } } if (parameters.GetParameter(context, type, "forceRen", false)) { return; } if (type.InheritsFromCorlib("System.Attribute")) { service.ReduceRenameMode(type, RenameMode.ASCII); } if (type.InheritsFrom("System.Configuration.SettingsBase")) { service.SetCanRename(type, false); } }
void DisableRename(ConfuserContext context, INameService service, ProtectionParameters parameters, TypeDef typeDef, string reason, bool memberOnly = true) { service.SetCanRename(typeDef, false, reason); foreach (MethodDef m in typeDef.Methods) { if (!parameters.GetParameter(context, m, "forceRen", false)) { service.SetCanRename(m, false, reason); } } foreach (FieldDef field in typeDef.Fields) { if (!parameters.GetParameter(context, field, "forceRen", false)) { service.SetCanRename(field, false, reason); } } foreach (PropertyDef prop in typeDef.Properties) { if (!parameters.GetParameter(context, prop, "forceRen", false)) { service.SetCanRename(prop, false, reason); } } foreach (EventDef evt in typeDef.Events) { if (!parameters.GetParameter(context, evt, "forceRen", false)) { service.SetCanRename(evt, false, reason); } } foreach (TypeDef nested in typeDef.NestedTypes) { DisableRename(context, service, parameters, nested, reason, false); } }
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 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 MethodDef decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member => { name.MarkHelper(member, marker); if (member is MethodDef) { ProtectionParameters.GetParameters(context, member).Remove(Parent); } }); InjectHelpers(context, compression, rt, moduleCtx); // Mutate codes MutateInitializer(moduleCtx, decomp); MethodDef cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod)); new MDPhase(moduleCtx).Hook(); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, EventDef evt) { if (evt.DeclaringType.IsVisibleOutside() && !parameters.GetParameter(context, evt, "renPublic", false)) { service.SetCanRename(evt, false); } else if (evt.IsRuntimeSpecialName || evt.IsSpecialName) { service.SetCanRename(evt, false); } }
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 MethodDef 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); MethodDef cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod)); new MDPhase(moduleCtx).Hook(); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, PropertyDef property) { bool setRename = service.CanRename(property.SetMethod); bool getRename = service.CanRename(property.GetMethod); if ((!setRename || !getRename) && parameters.GetParameter(context, property, "dontRenImpls", false)) { service.SetCanRename(property, false); } else if (IsVisibleOutside(context, parameters, property.DeclaringType) && property.IsPublic() && IsVisibleOutside(context, parameters, property)) { service.SetCanRename(property, false); } else if (property.IsRuntimeSpecialName) { service.SetCanRename(property, false); } else if (parameters.GetParameter(context, property, "forceRen", false)) { return; } else if (property.DeclaringType.Implements("System.ComponentModel.INotifyPropertyChanged")) { service.SetCanRename(property, false); } else if (property.DeclaringType.Name.String.Contains("AnonymousType")) { service.SetCanRename(property, false); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, TypeDef type) { if (IsVisibleOutside(context, parameters, type)) { service.SetCanRename(type, false); } else if (type.IsRuntimeSpecialName || type.IsGlobalModuleType) { service.SetCanRename(type, false); } else if (type.FullName == "ConfusedByAttribute") { // Courtesy service.SetCanRename(type, false); } /* * Can't rename Classes/Types that will be serialized */ if (type != null) { if (type.IsSerializable) { service.SetCanRename(type, false); } if (type.DeclaringType != null) { if (type.DeclaringType.IsSerializable) { service.SetCanRename(type, false); } } } if (parameters.GetParameter(context, type, "forceRen", false)) { return; } if (type.InheritsFromCorlib("System.Attribute")) { service.ReduceRenameMode(type, RenameMode.ASCII); } if (type.InheritsFrom("System.Configuration.SettingsBase")) { service.SetCanRename(type, false); } }
public static void ReplaceReference(CEContext ctx, ProtectionParameters parameters) { foreach (var entry in ctx.ReferenceRepl) { if (parameters.GetParameter <bool>(ctx.Context, entry.Key, "cfg")) { ReplaceCFG(entry.Key, entry.Value, ctx); } else { ReplaceNormal(entry.Key, entry.Value); } } }
CFContext ParseParameters(MethodDef method, ConfuserContext context, ProtectionParameters parameters, RandomGenerator random, bool disableOpti) { var ret = new CFContext(); ret.Type = parameters.GetParameter(context, method, "type", CFType.Switch); ret.Predicate = parameters.GetParameter(context, method, "predicate", PredicateType.Normal); int rawIntensity = parameters.GetParameter(context, method, "intensity", 60); ret.Intensity = rawIntensity / 100.0; ret.Depth = parameters.GetParameter(context, method, "depth", 4); ret.JunkCode = parameters.GetParameter(context, method, "junk", false) && !disableOpti; ret.Protection = (ControlFlowProtection)Parent; ret.Random = random; ret.Method = method; ret.Context = context; ret.DynCipher = context.Registry.GetService<IDynCipherService>(); if (ret.Predicate == PredicateType.x86) { if ((context.CurrentModule.Cor20HeaderFlags & ComImageFlags.ILOnly) != 0) context.CurrentModuleWriterOptions.Cor20HeaderOptions.Flags &= ~ComImageFlags.ILOnly; } return ret; }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, FieldDef field) { if (IsVisibleOutside(context, parameters, field.DeclaringType) && (field.IsFamily || field.IsFamilyOrAssembly || field.IsPublic) && IsVisibleOutside(context, parameters, field)) { service.SetCanRename(field, false); } else if (field.IsRuntimeSpecialName) { service.SetCanRename(field, false); } else if (parameters.GetParameter(context, field, "forceRen", false)) { return; } else if (field.DeclaringType.IsSerializable && !field.IsNotSerialized) { service.SetCanRename(field, false); } // unity support else if (field.HasAttribute("UnityEngine.SerializeField")) { service.SetCanRename(field, false); } else if (field.IsLiteral && field.DeclaringType.IsEnum && !parameters.GetParameter(context, field, "renEnum", false)) { service.SetCanRename(field, false); } }
// Token: 0x06000009 RID: 9 RVA: 0x00003FD8 File Offset: 0x000021D8 private static bool IsVisibleOutside(ConfuserContext context, ProtectionParameters parameters, IMemberDef def) { TypeDef type = def as TypeDef; if (type == null) { type = def.DeclaringType; } bool?renPublic = parameters.GetParameter <bool?>(context, type, "renPublic", null); if (!renPublic.HasValue) { return(type.IsVisibleOutside(true)); } return(type.IsVisibleOutside(false) && renPublic.Value); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (context.Packer == null) { return; } bool isExe = context.CurrentModule.Kind == ModuleKind.Windows || context.CurrentModule.Kind == ModuleKind.Console; if (context.Annotations.Get <CompressorContext>(context, Compressor.ContextKey) != null) { if (isExe) { context.Logger.Error("Too many executable modules!"); throw new ConfuserException(null); } return; } if (isExe) { var ctx = new CompressorContext { ModuleIndex = context.CurrentModuleIndex, Assembly = context.CurrentModule.Assembly, CompatMode = parameters.GetParameter(context, null, "compat", false) }; context.Annotations.Set(context, Compressor.ContextKey, ctx); ctx.ModuleName = context.CurrentModule.Name; ctx.EntryPoint = context.CurrentModule.EntryPoint; ctx.Kind = context.CurrentModule.Kind; if (!ctx.CompatMode) { context.CurrentModule.Name = "koi"; context.CurrentModule.EntryPoint = null; context.CurrentModule.Kind = ModuleKind.NetModule; } context.CurrentModuleWriterListener.OnWriterEvent += new ResourceRecorder(ctx, context.CurrentModule).OnWriterEvent; } }
private void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, FieldDef field) { if (field.DeclaringType.IsVisibleOutside() && (field.IsFamily || field.IsFamilyOrAssembly || field.IsPublic) && !parameters.GetParameter(context, field, "renPublic", false)) { service.SetCanRename(field, false); } else if (field.IsRuntimeSpecialName || field.IsSpecialName) { service.SetCanRename(field, false); } else if (field.DeclaringType.IsSerializable && !field.IsNotSerialized) { service.SetCanRename(field, false); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (!parameters.Targets.Any()) return; Mode mode = parameters.GetParameter(context, context.CurrentModule, "mode", Mode.Normal); IModeHandler modeHandler; switch (mode) { case Mode.Normal: modeHandler = new NormalMode(); break; case Mode.JIT: modeHandler = new JITMode(); break; default: throw new UnreachableException(); } modeHandler.HandleInject((AntiTamperProtection)Parent, context, parameters); context.Annotations.Set(context.CurrentModule, HandlerKey, modeHandler); }
static bool IsVisibleOutside(ConfuserContext context, ProtectionParameters parameters, IMemberDef def) { var type = def as TypeDef; if (type == null) { type = def.DeclaringType; } var renPublic = parameters.GetParameter <bool?>(context, def, "renPublic", null); if (renPublic == null) { return(type.IsVisibleOutside()); } else { return(type.IsVisibleOutside(false) && !renPublic.Value); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, MethodDef method) { if (IsVisibleOutside(context, parameters, method.DeclaringType) && (method.IsFamily || method.IsFamilyOrAssembly || method.IsPublic) && IsVisibleOutside(context, parameters, method)) { service.SetCanRename(method, false); } else if (method.IsRuntimeSpecialName) { service.SetCanRename(method, false); } else if (parameters.GetParameter(context, method, "forceRen", false)) { return; } else if (method.DeclaringType.IsComImport() && !method.HasAttribute("System.Runtime.InteropServices.DispIdAttribute")) { service.SetCanRename(method, false); } else if (method.DeclaringType.InheritsFrom("UnityEngine.MonoBehaviour") && momoBehaviourMethods.Contains(method.Name)) { service.SetCanRename(method, false); } else if (method.DeclaringType.InheritsFrom("UnityEngine.StateMachineBehaviour") && stateMachineBehaviourMethods.Contains(method.Name)) { service.SetCanRename(method, false); } else if (method.DeclaringType.IsDelegate()) { service.SetCanRename(method, false); } }
internal void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, IDnlibDef def, bool runAnalyzer) { if (def is TypeDef) Analyze(service, context, parameters, (TypeDef)def); else if (def is MethodDef) Analyze(service, context, parameters, (MethodDef)def); else if (def is FieldDef) Analyze(service, context, parameters, (FieldDef)def); else if (def is PropertyDef) Analyze(service, context, parameters, (PropertyDef)def); else if (def is EventDef) Analyze(service, context, parameters, (EventDef)def); else if (def is ModuleDef) service.SetCanRename(def, false); if (!runAnalyzer || parameters.GetParameter<bool>(context, def, "forceRen", false)) return; foreach (IRenamer renamer in service.Renamers) renamer.Analyze(context, service, def); }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, PropertyDef property) { if (IsVisibleOutside(context, parameters, property.DeclaringType) && (property.IsFamily() || property.IsFamilyOrAssembly() || property.IsPublic()) && IsVisibleOutside(context, parameters, property)) { service.SetCanRename(property, false); } else if (property.IsRuntimeSpecialName) { service.SetCanRename(property, false); } else if (property.IsExplicitlyImplementedInterfaceMember()) { service.SetCanRename(property, false); } else if (parameters.GetParameter(context, property, "forceRen", false)) { return; } else if (property.DeclaringType.Implements("System.ComponentModel.INotifyPropertyChanged")) { service.SetCanRename(property, false); } else if (property.DeclaringType.Name.String.Contains("AnonymousType")) { service.SetCanRename(property, false); } else if (property.IsAbstract()) { service.SetCanRename(property, false); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, MethodDef method) { if (!IsVisibleOutside(context, parameters, method.DeclaringType) || !method.IsFamily && !method.IsFamilyOrAssembly && !method.IsPublic || !IsVisibleOutside(context, parameters, method)) { if (!method.IsRuntimeSpecialName) { if (!parameters.GetParameter(context, method, "forceRen", false)) { if (!method.DeclaringType.IsComImport() || method.HasAttribute("System.Runtime.InteropServices.DispIdAttribute")) { if (method.DeclaringType.IsDelegate()) { service.SetCanRename(method, false); } } else { service.SetCanRename(method, false); } } else { return; } } else { service.SetCanRename(method, false); } } else { service.SetCanRename(method, false); } }
internal void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, IDnlibDef def, bool runAnalyzer) { if (def is TypeDef) { Analyze(service, context, parameters, (TypeDef)def); } else if (def is MethodDef) { Analyze(service, context, parameters, (MethodDef)def); } else if (def is FieldDef) { Analyze(service, context, parameters, (FieldDef)def); } else if (def is PropertyDef) { Analyze(service, context, parameters, (PropertyDef)def); } else if (def is EventDef) { Analyze(service, context, parameters, (EventDef)def); } else if (def is ModuleDef) { service.SetCanRename(def, false); } if (!runAnalyzer || parameters.GetParameter(context, def, "forceRen", false)) { return; } foreach (IRenamer renamer in service.Renamers) { renamer.Analyze(context, service, def); } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { if (context.Packer == null) return; bool isExe = context.CurrentModule.Kind == ModuleKind.Windows || context.CurrentModule.Kind == ModuleKind.Console; if (context.Annotations.Get<CompressorContext>(context, Compressor.ContextKey) != null) { if (isExe) { context.Logger.Error("Too many executable modules!"); throw new ConfuserException(null); } return; } if (isExe) { var ctx = new CompressorContext { ModuleIndex = context.CurrentModuleIndex, Assembly = context.CurrentModule.Assembly, CompatMode = parameters.GetParameter(context, null, "compat", false) }; context.Annotations.Set(context, Compressor.ContextKey, ctx); ctx.ModuleName = context.CurrentModule.Name; ctx.EntryPoint = context.CurrentModule.EntryPoint; ctx.Kind = context.CurrentModule.Kind; if (!ctx.CompatMode) { context.CurrentModule.Name = "koi"; context.CurrentModule.EntryPoint = null; context.CurrentModule.Kind = ModuleKind.NetModule; } context.CurrentModuleWriterListener.OnWriterEvent += new ResourceRecorder(ctx, context.CurrentModule).OnWriterEvent; } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, FieldDef field) { if (field.DeclaringType.IsVisibleOutside() && (field.IsFamily || field.IsFamilyOrAssembly || field.IsPublic) && !IsVisibleOutside(context, parameters, field)) service.SetCanRename(field, false); else if (field.IsRuntimeSpecialName) service.SetCanRename(field, false); else if (parameters.GetParameter(context, field, "forceRen", false)) return; else if (field.DeclaringType.IsSerializable && !field.IsNotSerialized) service.SetCanRename(field, false); else if (field.IsLiteral && field.DeclaringType.IsEnum) service.SetCanRename(field, false); }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, PropertyDef property) { if (property.DeclaringType.IsVisibleOutside() && !IsVisibleOutside(context, parameters, property)) service.SetCanRename(property, false); else if (property.IsRuntimeSpecialName) service.SetCanRename(property, false); else if (parameters.GetParameter(context, property, "forceRen", false)) return; else if (property.DeclaringType.Implements("System.ComponentModel.INotifyPropertyChanged")) service.SetCanRename(property, false); else if (property.DeclaringType.Name.String.Contains("AnonymousType")) service.SetCanRename(property, false); }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, TypeDef type) { if (IsVisibleOutside(context, parameters, type)) { service.SetCanRename(type, false); } else if (type.IsRuntimeSpecialName || type.IsGlobalModuleType) { service.SetCanRename(type, false); } else if (type.FullName == "ConfusedByAttribute") { // Courtesy service.SetCanRename(type, false); } if (parameters.GetParameter(context, type, "forceRen", false)) return; if (type.InheritsFromCorlib("System.Attribute")) { service.ReduceRenameMode(type, RenameMode.ASCII); } if (type.InheritsFrom("System.Configuration.SettingsBase")) { service.SetCanRename(type, false); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, MethodDef method) { if (method.DeclaringType.IsVisibleOutside() && (method.IsFamily || method.IsFamilyOrAssembly || method.IsPublic) && !IsVisibleOutside(context, parameters, method)) service.SetCanRename(method, false); else if (method.IsRuntimeSpecialName) service.SetCanRename(method, false); else if (parameters.GetParameter(context, method, "forceRen", false)) return; else if (method.DeclaringType.IsComImport() && !method.HasAttribute("System.Runtime.InteropServices.DispIdAttribute")) service.SetCanRename(method, false); else if (method.DeclaringType.IsDelegate()) service.SetCanRename(method, false); }
private void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, FieldDef field) { if (field.DeclaringType.IsVisibleOutside() && (field.IsFamily || field.IsFamilyOrAssembly || field.IsPublic) && !parameters.GetParameter<bool>(context, field, "renPublic", false)) service.SetCanRename(field, false); else if (field.IsRuntimeSpecialName || field.IsSpecialName) service.SetCanRename(field, false); }
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(); } }
public void PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null || !parameters.GetParameter<bool>(context, def, "renXaml", true)) return; var wpfResInfo = context.Annotations.Get<Dictionary<string, Dictionary<string, BamlDocument>>>(module, BAMLKey); if (wpfResInfo == null) return; foreach (var res in wpfResInfo.Values) foreach (var doc in res.Values) { List<IBAMLReference> references; if (bamlRefs.TryGetValue(doc.DocumentName, out references)) { var newName = doc.DocumentName.ToUpperInvariant(); #region old code //if (newName.EndsWith(".BAML")) // newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; //else if (newName.EndsWith(".XAML")) // newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; #endregion #region Niks patch fix /* * Nik's patch for maintaining relative paths. If the xaml file is referenced in this manner * "/some.namespace;component/somefolder/somecontrol.xaml" * then we want to keep the relative path and namespace intact. We should be obfuscating it like this - /some.namespace;component/somefolder/asjdjh2398498dswk.xaml * */ string[] completePath = newName.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries); string newShinyName = string.Empty; for (int i = 0; i <= completePath.Length - 2; i++) { newShinyName += completePath[i].ToLowerInvariant() + "/"; } if (newName.EndsWith(".BAML")) newName = newShinyName + service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; else if (newName.EndsWith(".XAML")) newName = newShinyName + service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; context.Logger.Debug(String.Format("Preserving virtual paths. Replaced {0} with {1}", doc.DocumentName, newName)); #endregion bool renameOk = true; foreach (var bamlRef in references) if (!bamlRef.CanRename(doc.DocumentName, newName)) { renameOk = false; break; } if (renameOk) { foreach (var bamlRef in references) bamlRef.Rename(doc.DocumentName, newName); doc.DocumentName = newName; } } } }
public void HandleInject(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters) { this.context = context; random = context.Registry.GetService<IRandomService>().GetRandomGenerator(parent.FullId); z = random.NextUInt32(); x = random.NextUInt32(); c = random.NextUInt32(); v = random.NextUInt32(); name1 = random.NextUInt32() & 0x7f7f7f7f; name2 = random.NextUInt32() & 0x7f7f7f7f; key = random.NextUInt32(); fieldLayout = new byte[6]; for (int i = 0; i < 6; i++) { int index = random.NextInt32(0, 6); while (fieldLayout[index] != 0) index = random.NextInt32(0, 6); fieldLayout[index] = (byte)i; } switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal)) { case Mode.Normal: deriver = new NormalDeriver(); break; case Mode.Dynamic: deriver = new DynamicDeriver(); break; default: throw new UnreachableException(); } deriver.Init(context, random); var rt = context.Registry.GetService<IRuntimeService>(); TypeDef initType = rt.GetRuntimeType("Confuser.Runtime.AntiTamperJIT"); IEnumerable<IDnlibDef> defs = InjectHelper.Inject(initType, context.CurrentModule.GlobalType, context.CurrentModule); initMethod = defs.OfType<MethodDef>().Single(method => method.Name == "Initialize"); initMethod.Body.SimplifyMacros(initMethod.Parameters); List<Instruction> instrs = initMethod.Body.Instructions.ToList(); for (int i = 0; i < instrs.Count; i++) { Instruction instr = instrs[i]; if (instr.OpCode == OpCodes.Ldtoken) { instr.Operand = context.CurrentModule.GlobalType; } else 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, deriver.EmitDerivation(initMethod, context, (Local)ldDst.Operand, (Local)ldSrc.Operand)); } } } initMethod.Body.Instructions.Clear(); foreach (Instruction instr in instrs) initMethod.Body.Instructions.Add(instr); MutationHelper.InjectKeys(initMethod, new[] { 0, 1, 2, 3, 4 }, new[] { (int)(name1 * name2), (int)z, (int)x, (int)c, (int)v }); var name = context.Registry.GetService<INameService>(); var marker = context.Registry.GetService<IMarkerService>(); cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctorRepl = new MethodDefUser(name.RandomName(), MethodSig.CreateStatic(context.CurrentModule.CorLibTypes.Void)); cctorRepl.IsStatic = true; cctorRepl.Access = MethodAttributes.CompilerControlled; cctorRepl.Body = new CilBody(); cctorRepl.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); context.CurrentModule.GlobalType.Methods.Add(cctorRepl); name.MarkHelper(cctorRepl, marker, parent); MutationHelper.InjectKeys(defs.OfType<MethodDef>().Single(method => method.Name == "HookHandler"), new[] { 0 }, new[] { (int)key }); foreach (IDnlibDef def in defs) { if (def.Name == "MethodData") { var dataType = (TypeDef)def; FieldDef[] fields = dataType.Fields.ToArray(); var layout = fieldLayout.Clone() as byte[]; Array.Sort(layout, fields); for (byte j = 0; j < 6; j++) layout[j] = j; Array.Sort(fieldLayout, layout); fieldLayout = layout; dataType.Fields.Clear(); foreach (FieldDef f in fields) dataType.Fields.Add(f); } name.MarkHelper(def, marker, parent); if (def is MethodDef) parent.ExcludeMethod(context, (MethodDef)def); } parent.ExcludeMethod(context, cctor); }
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 pdbDocs = new HashSet<string>(); 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); 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(); } }
static bool IsVisibleOutside(ConfuserContext context, ProtectionParameters parameters, IMemberDef def) { var type = def as TypeDef; if (type == null) type = def.DeclaringType; var renPublic = parameters.GetParameter<bool?>(context, type, "renPublic", null); if (renPublic == null) return type.IsVisibleOutside(); else return type.IsVisibleOutside(false) && renPublic.Value; }
public void PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null || !parameters.GetParameter<bool>(context, def, "renXaml", true)) return; var wpfResInfo = context.Annotations.Get<Dictionary<string, Dictionary<string, BamlDocument>>>(module, BAMLKey); if (wpfResInfo == null) return; foreach (var res in wpfResInfo.Values) foreach (var doc in res.Values) { List<IBAMLReference> references; if (bamlRefs.TryGetValue(doc.DocumentName, out references)) { var newName = doc.DocumentName.ToUpperInvariant(); if (newName.EndsWith(".BAML")) newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; else if (newName.EndsWith(".XAML")) newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; bool renameOk = true; foreach (var bamlRef in references) if (!bamlRef.CanRename(doc.DocumentName, newName)) { renameOk = false; break; } if (renameOk) { foreach (var bamlRef in references) bamlRef.Rename(doc.DocumentName, newName); doc.DocumentName = newName; } } } }
public void HandleInject(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters) { random = context.Registry.GetService<IRandomService>().GetRandomGenerator(parent.FullId); z = random.NextUInt32(); x = random.NextUInt32(); c = random.NextUInt32(); v = random.NextUInt32(); name1 = random.NextUInt32() & 0x7f7f7f7f; name2 = random.NextUInt32() & 0x7f7f7f7f; switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal)) { case Mode.Normal: deriver = new NormalDeriver(); break; case Mode.Dynamic: deriver = new DynamicDeriver(); break; default: throw new UnreachableException(); } deriver.Init(context, random); var rt = context.Registry.GetService<IRuntimeService>(); TypeDef initType = rt.GetRuntimeType("Confuser.Runtime.AntiTamperNormal"); IEnumerable<IDnlibDef> members = InjectHelper.Inject(initType, context.CurrentModule.GlobalType, context.CurrentModule); var initMethod = (MethodDef)members.Single(m => m.Name == "Initialize"); initMethod.Body.SimplifyMacros(initMethod.Parameters); List<Instruction> instrs = initMethod.Body.Instructions.ToList(); for (int i = 0; i < instrs.Count; i++) { Instruction instr = instrs[i]; if (instr.OpCode == OpCodes.Ldtoken) { instr.Operand = context.CurrentModule.GlobalType; } else 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, deriver.EmitDerivation(initMethod, context, (Local)ldDst.Operand, (Local)ldSrc.Operand)); } } } initMethod.Body.Instructions.Clear(); foreach (Instruction instr in instrs) initMethod.Body.Instructions.Add(instr); MutationHelper.InjectKeys(initMethod, new[] { 0, 1, 2, 3, 4 }, new[] { (int)(name1 * name2), (int)z, (int)x, (int)c, (int)v }); var name = context.Registry.GetService<INameService>(); var marker = context.Registry.GetService<IMarkerService>(); foreach (IDnlibDef def in members) { name.MarkHelper(def, marker, parent); if (def is MethodDef) parent.ExcludeMethod(context, (MethodDef)def); } MethodDef cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, initMethod)); parent.ExcludeMethod(context, cctor); }
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>(); IEnumerable<IDnlibDef> defs = InjectHelper.Inject(rt.GetRuntimeType("Confuser.Runtime.Compressor"), stubModule.GlobalType, stubModule); switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal)) { 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 ParseParameters(IDnlibDef def, ConfuserContext context, NameService service, ProtectionParameters parameters) { var mode = parameters.GetParameter<RenameMode?>(context, def, "mode", null); if (mode != null) service.SetRenameMode(def, mode.Value); }
public void PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null || !parameters.GetParameter(context, def, "renXaml", true)) { return; } var wpfResInfo = context.Annotations.Get <Dictionary <string, Dictionary <string, BamlDocument> > >(module, BAMLKey); if (wpfResInfo == null) { return; } foreach (var res in wpfResInfo.Values) { foreach (var doc in res.Values) { List <IBAMLReference> references; if (bamlRefs.TryGetValue(doc.DocumentName, out references)) { var newName = doc.DocumentName.ToUpperInvariant(); #region old code //if (newName.EndsWith(".BAML")) // newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; //else if (newName.EndsWith(".XAML")) // newName = service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; #endregion #region Niks patch fix /* * Nik's patch for maintaining relative paths. If the xaml file is referenced in this manner * "/some.namespace;component/somefolder/somecontrol.xaml" * then we want to keep the relative path and namespace intact. We should be obfuscating it like this - /some.namespace;component/somefolder/asjdjh2398498dswk.xaml * */ var completePath = newName.Split(new[] { "/" }, StringSplitOptions.RemoveEmptyEntries); var newShinyName = string.Empty; for (var i = 0; i <= completePath.Length - 2; i++) { newShinyName += completePath[i].ToLowerInvariant() + "/"; } if (newName.EndsWith(".BAML")) { newName = newShinyName + service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".baml"; } else if (newName.EndsWith(".XAML")) { newName = newShinyName + service.RandomName(RenameMode.Letters).ToLowerInvariant() + ".xaml"; } context.Logger.Debug(string.Format("Preserving virtual paths. Replaced {0} with {1}", doc.DocumentName, newName)); #endregion var renameOk = true; foreach (var bamlRef in references) { if (!bamlRef.CanRename(doc.DocumentName, newName)) { renameOk = false; break; } } if (renameOk) { foreach (var bamlRef in references) { bamlRef.Rename(doc.DocumentName, newName); } doc.DocumentName = newName; } } } } }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { var rt = context.Registry.GetService<IRuntimeService>(); var marker = context.Registry.GetService<IMarkerService>(); var name = context.Registry.GetService<INameService>(); foreach (ModuleDef module in parameters.Targets.OfType<ModuleDef>()) { AntiMode mode = parameters.GetParameter(context, module, "mode", AntiMode.Safe); TypeDef rtType; TypeDef attr = null; const string attrName = "System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute"; switch (mode) { case AntiMode.Safe: rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugSafe"); break; case AntiMode.Win32: rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugWin32"); break; case AntiMode.Antinet: rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugAntinet"); attr = rt.GetRuntimeType(attrName); module.Types.Add(attr = InjectHelper.Inject(attr, module)); foreach (IDnlibDef member in attr.FindDefinitions()) { marker.Mark(member, (Protection)Parent); name.Analyze(member); } name.SetCanRename(attr, false); break; default: throw new UnreachableException(); } IEnumerable<IDnlibDef> members = InjectHelper.Inject(rtType, module.GlobalType, module); MethodDef cctor = module.GlobalType.FindStaticConstructor(); var init = (MethodDef)members.Single(method => method.Name == "Initialize"); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (IDnlibDef member in members) { marker.Mark(member, (Protection)Parent); name.Analyze(member); bool ren = true; if (member is MethodDef) { var method = (MethodDef)member; if (method.Access == MethodAttributes.Public) method.Access = MethodAttributes.Assembly; if (!method.IsConstructor) method.IsSpecialName = false; else ren = false; CustomAttribute ca = method.CustomAttributes.Find(attrName); if (ca != null) ca.Constructor = attr.FindMethod(".ctor"); } else if (member is FieldDef) { var field = (FieldDef)member; if (field.Access == FieldAttributes.Public) field.Access = FieldAttributes.Assembly; if (field.IsLiteral) { field.DeclaringType.Fields.Remove(field); continue; } } if (ren) { member.Name = name.ObfuscateName(member.Name, RenameMode.Unicode); name.SetCanRename(member, false); } } } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, EventDef evt) { if (evt.DeclaringType.IsVisibleOutside() && !parameters.GetParameter(context, evt, "renPublic", false)) service.SetCanRename(evt, false); else if (evt.IsRuntimeSpecialName) service.SetCanRename(evt, false); }
public void HandleInject(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters) { this.context = context; random = context.Registry.GetService <IRandomService>().GetRandomGenerator(parent.FullId); z = random.NextUInt32(); x = random.NextUInt32(); c = random.NextUInt32(); v = random.NextUInt32(); name1 = random.NextUInt32() & 0x7f7f7f7f; name2 = random.NextUInt32() & 0x7f7f7f7f; key = random.NextUInt32(); fieldLayout = new byte[6]; for (int i = 0; i < 6; i++) { int index = random.NextInt32(0, 6); while (fieldLayout[index] != 0) { index = random.NextInt32(0, 6); } fieldLayout[index] = (byte)i; } switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal)) { case Mode.Normal: deriver = new NormalDeriver(); break; case Mode.Dynamic: deriver = new DynamicDeriver(); break; default: throw new UnreachableException(); } deriver.Init(context, random); var rt = context.Registry.GetService <IRuntimeService>(); TypeDef initType = rt.GetRuntimeType("Confuser.Runtime.AntiTamperJIT"); IEnumerable <IDnlibDef> defs = InjectHelper.Inject(initType, context.CurrentModule.GlobalType, context.CurrentModule); initMethod = defs.OfType <MethodDef>().Single(method => method.Name == "Initialize"); initMethod.Body.SimplifyMacros(initMethod.Parameters); List <Instruction> instrs = initMethod.Body.Instructions.ToList(); for (int i = 0; i < instrs.Count; i++) { Instruction instr = instrs[i]; if (instr.OpCode == OpCodes.Ldtoken) { instr.Operand = context.CurrentModule.GlobalType; } else 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, deriver.EmitDerivation(initMethod, context, (Local)ldDst.Operand, (Local)ldSrc.Operand)); } } } initMethod.Body.Instructions.Clear(); foreach (Instruction instr in instrs) { initMethod.Body.Instructions.Add(instr); } MutationHelper.InjectKeys(initMethod, new[] { 0, 1, 2, 3, 4 }, new[] { (int)(name1 * name2), (int)z, (int)x, (int)c, (int)v }); var name = context.Registry.GetService <INameService>(); var marker = context.Registry.GetService <IMarkerService>(); cctor = context.CurrentModule.GlobalType.FindStaticConstructor(); cctorRepl = new MethodDefUser(name.RandomName(), MethodSig.CreateStatic(context.CurrentModule.CorLibTypes.Void)); cctorRepl.IsStatic = true; cctorRepl.Access = MethodAttributes.CompilerControlled; cctorRepl.Body = new CilBody(); cctorRepl.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); context.CurrentModule.GlobalType.Methods.Add(cctorRepl); name.MarkHelper(cctorRepl, marker, parent); MutationHelper.InjectKeys(defs.OfType <MethodDef>().Single(method => method.Name == "HookHandler"), new[] { 0 }, new[] { (int)key }); foreach (IDnlibDef def in defs) { if (def.Name == "MethodData") { var dataType = (TypeDef)def; FieldDef[] fields = dataType.Fields.ToArray(); var layout = fieldLayout.Clone() as byte[]; Array.Sort(layout, fields); for (byte j = 0; j < 6; j++) { layout[j] = j; } Array.Sort(fieldLayout, layout); fieldLayout = layout; dataType.Fields.Clear(); foreach (FieldDef f in fields) { dataType.Fields.Add(f); } } name.MarkHelper(def, marker, parent); if (def is MethodDef) { parent.ExcludeMethod(context, (MethodDef)def); } } parent.ExcludeMethod(context, cctor); }
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(); } }
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); }
RPContext ParseParameters(MethodDef method, ConfuserContext context, ProtectionParameters parameters, RPStore store) { var ret = new RPContext(); ret.Mode = parameters.GetParameter(context, method, "mode", Mode.Mild); ret.Encoding = parameters.GetParameter(context, method, "encoding", EncodingType.Normal); ret.InternalAlso = parameters.GetParameter(context, method, "internal", false); ret.TypeErasure = parameters.GetParameter(context, method, "typeErasure", false); ret.Depth = parameters.GetParameter(context, method, "depth", 3); ret.Module = method.Module; ret.Method = method; ret.Body = method.Body; ret.BranchTargets = new HashSet <Instruction>( method.Body.Instructions .Select(instr => instr.Operand as Instruction) .Concat(method.Body.Instructions .Where(instr => instr.Operand is Instruction[]) .SelectMany(instr => (Instruction[])instr.Operand)) .Where(target => target != null)); ret.Protection = (ReferenceProxyProtection)Parent; ret.Random = store.random; ret.Context = context; ret.Marker = context.Registry.GetService <IMarkerService>(); ret.DynCipher = context.Registry.GetService <IDynCipherService>(); ret.Name = context.Registry.GetService <INameService>(); ret.Delegates = store.delegates; switch (ret.Mode) { case Mode.Mild: ret.ModeHandler = store.mild ?? (store.mild = new MildMode()); break; case Mode.Strong: ret.ModeHandler = store.strong ?? (store.strong = new StrongMode()); break; default: throw new UnreachableException(); } switch (ret.Encoding) { case EncodingType.Normal: ret.EncodingHandler = store.normal ?? (store.normal = new NormalEncoding()); break; case EncodingType.Expression: ret.EncodingHandler = store.expression ?? (store.expression = new ExpressionEncoding()); break; case EncodingType.x86: ret.EncodingHandler = store.x86 ?? (store.x86 = new x86Encoding()); if ((context.CurrentModule.Cor20HeaderFlags & ComImageFlags.ILOnly) != 0) { context.CurrentModuleWriterOptions.Cor20HeaderOptions.Flags &= ~ComImageFlags.ILOnly; } break; default: throw new UnreachableException(); } return(ret); }
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); } }
private void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, TypeDef type) { if (type.IsVisibleOutside() && !parameters.GetParameter<bool>(context, type, "renPublic", false)) { service.SetCanRename(type, false); } else if (type.IsRuntimeSpecialName || type.IsSpecialName) { service.SetCanRename(type, false); } else if (type.FullName == "ConfusedByAttribute") { // Courtesy service.SetCanRename(type, false); } if (parameters.GetParameter<bool>(context, type, "forceRen", false)) return; if (type.InheritsFromCorlib("System.Attribute")) { service.ReduceRenameMode(type, RenameMode.ASCII); } }