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);
}
}