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
};
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.CurrentModuleWriterListener.OnWriterEvent += new ResourceRecorder(ctx, context.CurrentModule).OnWriterEvent;
}
}
protected override void Pack(ConfuserContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get<CompressorContext>(context, ContextKey);
if (ctx == null) {
context.Logger.Error("No executable module!");
throw new ConfuserException(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
ctx.Assembly.Modules.Insert(0, stubModule);
stubModule.Characteristics = originModule.Characteristics;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get<StrongNameKey>(originModule, Marker.SNKey);
using (var ms = new MemoryStream()) {
stubModule.Write(ms, new ModuleWriterOptions(stubModule, new KeyInjector(ctx)) {
StrongNameKey = snKey
});
context.CheckCancellation();
base.ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, new StubProtection(ctx));
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) {
var field = context.CurrentModule.Types[0].FindField("DataField");
Debug.Assert(field != null);
context.Registry.GetService<INameService>().SetCanRename(field, true);
context.CurrentModuleWriterListener.OnWriterEvent += (sender, e) => {
if (e.WriterEvent == ModuleWriterEvent.MDBeginCreateTables) {
// Add key signature
var writer = (ModuleWriterBase)sender;
var prot = (StubProtection)Parent;
uint blob = writer.MetaData.BlobHeap.Add(prot.ctx.KeySig);
uint rid = writer.MetaData.TablesHeap.StandAloneSigTable.Add(new RawStandAloneSigRow(blob));
Debug.Assert((0x11000000 | rid) == prot.ctx.KeyToken);
if (prot.ctx.CompatMode)
return;
// Add File reference
byte[] hash = SHA1.Create().ComputeHash(prot.ctx.OriginModule);
uint hashBlob = writer.MetaData.BlobHeap.Add(hash);
MDTable<RawFileRow> fileTbl = writer.MetaData.TablesHeap.FileTable;
uint fileRid = fileTbl.Add(new RawFileRow(
(uint)FileAttributes.ContainsMetaData,
writer.MetaData.StringsHeap.Add("koi"),
hashBlob));
}
};
}
// i.e. Inter-Assembly References, e.g. InternalVisibleToAttributes
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDefMD;
if (module == null) return;
// MemberRef/MethodSpec
var methods = module.GetTypes().SelectMany(type => type.Methods);
foreach(var methodDef in methods) {
foreach (var ov in methodDef.Overrides) {
ProcessMemberRef(context, service, module, ov.MethodBody);
ProcessMemberRef(context, service, module, ov.MethodDeclaration);
}
if (!methodDef.HasBody)
continue;
foreach (var instr in methodDef.Body.Instructions) {
if (instr.Operand is MemberRef || instr.Operand is MethodSpec)
ProcessMemberRef(context, service, module, (IMemberRef)instr.Operand);
}
}
// TypeRef
var table = module.TablesStream.Get(Table.TypeRef);
uint len = table.Rows;
for (uint i = 1; i <= len; i++) {
TypeRef typeRef = module.ResolveTypeRef(i);
TypeDef typeDef = typeRef.ResolveTypeDefThrow();
if (typeDef.Module != module && context.Modules.Contains((ModuleDefMD)typeDef.Module)) {
service.AddReference(typeDef, new TypeRefReference(typeRef, typeDef));
}
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var service = (NameService)context.Registry.GetService<INameService>();
context.Logger.Debug("Building VTables & identifier list...");
foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) {
ParseParameters(def, context, service, parameters);
if (def is ModuleDef) {
var module = (ModuleDef)def;
foreach (Resource res in module.Resources)
service.SetOriginalName(res, res.Name);
}
else
service.SetOriginalName(def, def.Name);
if (def is TypeDef) {
service.GetVTables().GetVTable((TypeDef)def);
service.SetOriginalNamespace(def, ((TypeDef)def).Namespace);
}
context.CheckCancellation();
}
context.Logger.Debug("Analyzing...");
RegisterRenamers(context, service);
IList<IRenamer> renamers = service.Renamers;
foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger)) {
Analyze(service, context, parameters, def, true);
context.CheckCancellation();
}
}
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;
}
}
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);
}
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);
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) {
foreach (ModuleDef module in parameters.Targets.OfType<ModuleDef>()) {
TypeRef attrRef = module.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressIldasmAttribute");
var ctorRef = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRef);
var attr = new CustomAttribute(ctorRef);
module.CustomAttributes.Add(attr);
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) {
var method = def as MethodDef;
if (method == null || !method.HasBody)
return;
// When a ldtoken instruction reference a definition,
// most likely it would be used in reflection and thus probably should not be renamed.
// Also, when ToString is invoked on enum,
// the enum should not be renamed.
for (int i = 0; i < method.Body.Instructions.Count; i++) {
Instruction instr = method.Body.Instructions[i];
if (instr.OpCode.Code == Code.Ldtoken) {
if (instr.Operand is MemberRef) {
IMemberForwarded member = ((MemberRef)instr.Operand).ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)member.Module))
service.SetCanRename(member, false);
}
else if (instr.Operand is IField) {
FieldDef field = ((IField)instr.Operand).ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)field.Module))
service.SetCanRename(field, false);
}
else if (instr.Operand is IMethod) {
var im = (IMethod)instr.Operand;
if (!im.IsArrayAccessors()) {
MethodDef m = im.ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)m.Module))
service.SetCanRename(method, false);
}
}
else if (instr.Operand is ITypeDefOrRef) {
if (!(instr.Operand is TypeSpec)) {
TypeDef type = ((ITypeDefOrRef)instr.Operand).ResolveTypeDefThrow();
if (context.Modules.Contains((ModuleDefMD)type.Module) &&
HandleTypeOf(context, service, method, i)) {
var t = type;
do {
DisableRename(service, t, false);
t = t.DeclaringType;
} while (t != null);
}
}
}
else
throw new UnreachableException();
}
else if ((instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) &&
((IMethod)instr.Operand).Name == "ToString") {
HandleEnum(context, service, method, i);
}
else if (instr.OpCode.Code == Code.Ldstr) {
TypeDef typeDef = method.Module.FindReflection((string)instr.Operand);
if (typeDef != null)
service.AddReference(typeDef, new StringTypeReference(instr, typeDef));
}
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) {
var service = (NameService)context.Registry.GetService<INameService>();
foreach (IRenamer renamer in service.Renamers) {
foreach (IDnlibDef def in parameters.Targets)
renamer.PostRename(context, service, parameters, def);
context.CheckCancellation();
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var 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) {
bool disabledOpti = DisabledOptimization(context.CurrentModule);
RandomGenerator random = context.Registry.GetService<IRandomService>().GetRandomGenerator(ControlFlowProtection._FullId);
foreach (MethodDef method in parameters.Targets.OfType<MethodDef>().WithProgress(context.Logger))
if (method.HasBody && method.Body.Instructions.Count > 0) {
ProcessMethod(method.Body, ParseParameters(method, context, parameters, random, disabledOpti));
context.CheckCancellation();
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
if (def is TypeDef)
Analyze(context, service, (TypeDef)def, parameters);
else if (def is MethodDef)
Analyze(context, service, (MethodDef)def, parameters);
else if (def is PropertyDef)
Analyze(context, service, (PropertyDef)def, parameters);
else if (def is FieldDef)
Analyze(context, service, (FieldDef)def, parameters);
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDef;
if (module == null) return;
string asmName = module.Assembly.Name.String;
if (!string.IsNullOrEmpty(module.Assembly.Culture) &&
asmName.EndsWith(".resources")) {
// Satellite assembly
var satellitePattern = new Regex(string.Format("^(.*)\\.{0}\\.resources$", module.Assembly.Culture));
string nameAsmName = asmName.Substring(0, asmName.Length - ".resources".Length);
ModuleDef mainModule = context.Modules.SingleOrDefault(mod => mod.Assembly.Name == nameAsmName);
if (mainModule == null) {
context.Logger.ErrorFormat("Could not find main assembly of satellite assembly '{0}'.", module.Assembly.FullName);
throw new ConfuserException(null);
}
string format = "{0}." + module.Assembly.Culture + ".resources";
foreach (Resource res in module.Resources) {
Match match = satellitePattern.Match(res.Name);
if (!match.Success)
continue;
string typeName = match.Groups[1].Value;
TypeDef type = mainModule.FindReflectionThrow(typeName);
if (type == null) {
context.Logger.WarnFormat("Could not find resource type '{0}'.", typeName);
continue;
}
service.ReduceRenameMode(type, RenameMode.ASCII);
service.AddReference(type, new ResourceReference(res, type, format));
}
}
else {
string format = "{0}.resources";
foreach (Resource res in module.Resources) {
Match match = ResourceNamePattern.Match(res.Name);
if (!match.Success)
continue;
string typeName = match.Groups[1].Value;
if (typeName.EndsWith(".g")) // WPF resources, ignore
continue;
TypeDef type = module.FindReflection(typeName);
if (type == null) {
context.Logger.WarnFormat("Could not find resource type '{0}'.", typeName);
continue;
}
service.ReduceRenameMode(type, RenameMode.ASCII);
service.AddReference(type, new ResourceReference(res, type, format));
}
}
}
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);
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) {
var method = def as MethodDef;
if (method != null) {
if (!method.HasBody)
return;
AnalyzeMethod(context, service, method);
}
var module = def as ModuleDefMD;
if (module != null) {
AnalyzeResources(context, service, module);
}
}
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();
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) {
if (def is ModuleDef) {
foreach (var type in ((ModuleDef)def).GetTypes())
foreach (var prop in type.Properties)
properties.AddListEntry(prop.Name, prop);
return;
}
var method = def as MethodDef;
if (method == null || !method.HasBody)
return;
AnalyzeMethod(context, service, method);
}
public void PostRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDefMD;
if (module == null)
return;
var wpfResInfo = context.Annotations.Get<Dictionary<string, Dictionary<string, BamlDocument>>>(module, BAMLKey);
if (wpfResInfo == null)
return;
foreach (EmbeddedResource res in module.Resources.OfType<EmbeddedResource>())
{
Dictionary<string, BamlDocument> resInfo;
if (!wpfResInfo.TryGetValue(res.Name, out resInfo))
continue;
var stream = new MemoryStream();
var writer = new ResourceWriter(stream);
res.Data.Position = 0;
var reader = new ResourceReader(new ImageStream(res.Data));
IDictionaryEnumerator enumerator = reader.GetEnumerator();
while (enumerator.MoveNext())
{
var name = (string)enumerator.Key;
string typeName;
byte[] data;
reader.GetResourceData(name, out typeName, out data);
BamlDocument document;
if (resInfo.TryGetValue(name, out document))
{
var docStream = new MemoryStream();
docStream.Position = 4;
BamlWriter.WriteDocument(document, docStream);
docStream.Position = 0;
docStream.Write(BitConverter.GetBytes((int)docStream.Length - 4), 0, 4);
data = docStream.ToArray();
name = document.DocumentName;
}
writer.AddResourceData(name, typeName, data);
}
writer.Generate();
res.Data = MemoryImageStream.Create(stream.ToArray());
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) {
var srv = (NameService)context.Registry.GetService<INameService>();
var map = srv.GetNameMap();
if (map.Count == 0)
return;
string path = Path.GetFullPath(Path.Combine(context.OutputDirectory, "symbols.map"));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
Directory.CreateDirectory(dir);
using (var writer = new StreamWriter(File.OpenWrite(path))) {
foreach (var entry in map)
writer.WriteLine("{0}\t{1}", entry.Key, entry.Value);
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) {
TypeDef rtType = context.Registry.GetService<IRuntimeService>().GetRuntimeType("Confuser.Runtime.AntiDump");
var marker = context.Registry.GetService<IMarkerService>();
var name = context.Registry.GetService<INameService>();
foreach (ModuleDef module in parameters.Targets.OfType<ModuleDef>()) {
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)
name.MarkHelper(member, marker, (Protection)Parent);
}
}
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);
}
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);
}
}
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);
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) {
var type = def as TypeDef;
if (type == null || type.DeclaringType != null)
return;
if (type.Name.Contains("ViewModel")) {
string viewNs = type.Namespace.Replace("ViewModels", "Views");
string viewName = type.Name.Replace("PageViewModel", "Page").Replace("ViewModel", "View");
TypeDef view = type.Module.Find(viewNs + "." + viewName, true);
if (view != null) {
service.SetCanRename(type, false);
service.SetCanRename(view, false);
}
// Test for Multi-view
string multiViewNs = type.Namespace + "." + type.Name.Replace("ViewModel", "");
foreach (var t in type.Module.Types)
if (t.Namespace == multiViewNs) {
service.SetCanRename(type, false);
service.SetCanRename(t, false);
}
}
}
// i.e. Inter-Assembly References, e.g. InternalVisibleToAttributes
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDefMD;
if (module == null) return;
MDTable table;
uint len;
// MemberRef
table = module.TablesStream.Get(Table.MemberRef);
len = table.Rows;
for (uint i = 1; i <= len; i++) {
MemberRef memberRef = module.ResolveMemberRef(i);
if (memberRef.DeclaringType.TryGetArraySig() != null)
continue;
TypeDef declType = memberRef.DeclaringType.ResolveTypeDefThrow();
if (declType.Module != module && context.Modules.Contains((ModuleDefMD)declType.Module)) {
var memberDef = (IDnlibDef)declType.ResolveThrow(memberRef);
service.AddReference(memberDef, new MemberRefReference(memberRef, memberDef));
}
}
// TypeRef
table = module.TablesStream.Get(Table.TypeRef);
len = table.Rows;
for (uint i = 1; i <= len; i++) {
TypeRef typeRef = module.ResolveTypeRef(i);
TypeDef typeDef = typeRef.ResolveTypeDefThrow();
if (typeDef.Module != module && context.Modules.Contains((ModuleDefMD)typeDef.Module)) {
service.AddReference(typeDef, new TypeRefReference(typeRef, typeDef));
}
}
}
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 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 InjectHelpers(DotProtectContext context, ICompressionService compression, IRuntimeService rt, CEContext moduleCtx)
{
IEnumerable <IDnlibDef> members = InjectHelper.Inject(rt.GetRuntimeType("DotProtect.Runtime.Constant"), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (IDnlibDef member in members)
{
if (member.Name == "Get")
{
context.CurrentModule.GlobalType.Remove((MethodDef)member);
continue;
}
if (member.Name == "b")
{
moduleCtx.BufferField = (FieldDef)member;
}
else if (member.Name == "Initialize")
{
moduleCtx.InitMethod = (MethodDef)member;
}
moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent);
}
ProtectionParameters.GetParameters(context, moduleCtx.InitMethod).Remove(Parent);
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"));
dataType.Layout = TypeAttributes.ExplicitLayout;
dataType.Visibility = TypeAttributes.NestedPrivate;
dataType.IsSealed = true;
moduleCtx.DataType = dataType;
context.CurrentModule.GlobalType.NestedTypes.Add(dataType);
moduleCtx.Name.MarkHelper(dataType, moduleCtx.Marker, (Protection)Parent);
moduleCtx.DataField = new FieldDefUser(moduleCtx.Name.RandomName(), new FieldSig(dataType.ToTypeSig()))
{
IsStatic = true,
Access = FieldAttributes.CompilerControlled
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent);
MethodDef decoder = rt.GetRuntimeType("DotProtect.Runtime.Constant").FindMethod("Get");
moduleCtx.Decoders = new List <Tuple <MethodDef, DecoderDesc> >();
for (int i = 0; i < moduleCtx.DecoderCount; i++)
{
MethodDef decoderInst = InjectHelper.Inject(decoder, context.CurrentModule);
for (int j = 0; j < decoderInst.Body.Instructions.Count; j++)
{
Instruction instr = decoderInst.Body.Instructions[j];
var method = instr.Operand as IMethod;
var field = instr.Operand as IField;
if (instr.OpCode == OpCodes.Call &&
method.DeclaringType.Name == "Mutation" &&
method.Name == "Value")
{
decoderInst.Body.Instructions[j] = Instruction.Create(OpCodes.Sizeof, new GenericMVar(0).ToTypeDefOrRef());
}
else if (instr.OpCode == OpCodes.Ldsfld &&
method.DeclaringType.Name == "Constant")
{
if (field.Name == "b")
{
instr.Operand = moduleCtx.BufferField;
}
else
{
throw new UnreachableException();
}
}
}
context.CurrentModule.GlobalType.Methods.Add(decoderInst);
moduleCtx.Name.MarkHelper(decoderInst, moduleCtx.Marker, (Protection)Parent);
ProtectionParameters.GetParameters(context, decoderInst).Remove(Parent);
var decoderDesc = new DecoderDesc();
decoderDesc.StringID = (byte)(moduleCtx.Random.NextByte() & 3);
do
{
decoderDesc.NumberID = (byte)(moduleCtx.Random.NextByte() & 3);
} while (decoderDesc.NumberID == decoderDesc.StringID);
do
{
decoderDesc.InitializerID = (byte)(moduleCtx.Random.NextByte() & 3);
} while (decoderDesc.InitializerID == decoderDesc.StringID || decoderDesc.InitializerID == decoderDesc.NumberID);
MutationHelper.InjectKeys(decoderInst,
new[] { 0, 1, 2 },
new int[] { decoderDesc.StringID, decoderDesc.NumberID, decoderDesc.InitializerID });
decoderDesc.Data = moduleCtx.ModeHandler.CreateDecoder(decoderInst, moduleCtx);
moduleCtx.Decoders.Add(Tuple.Create(decoderInst, decoderDesc));
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
context.CurrentModuleWriterListener.OnWriterEvent += CurrentModuleWriterListener_OnWriterEvent;
}
/// <inheritdoc />
public bool IsMarked(IDnlibDef def)
{
return(ProtectionParameters.GetParameters(context, def) != null);
}
void IRenamer.PreRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
}
public void PreRename(DotProtectContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
//
}
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();
}
}
protected internal override void Execute(DotProtectContext 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
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));
context.Annotations.Set(context.CurrentModule, ConstantProtection.ContextKey, moduleCtx);
}
}
public void PostRename(ConfuserContext context, INameService service, ProtectionParameters parameters, ISDnlibDef def)
{
//
}
protected override void Pack(ConfuserContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey);
if (ctx == null)
{
context.Logger.Error("No executable module!");
throw new ConfuserException(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
ctx.OriginModuleDef = originModule;
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
if (ctx.CompatMode)
{
var assembly = new AssemblyDefUser(originModule.Assembly);
assembly.Name += ".cr";
assembly.Modules.Add(stubModule);
}
else
{
ctx.Assembly.Modules.Insert(0, stubModule);
ImportAssemblyTypeReferences(originModule, stubModule);
}
stubModule.Characteristics = originModule.Characteristics;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey);
var snPubKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNPubKey);
var snDelaySig = context.Annotations.Get <bool>(originModule, Marker.SNDelaySig, false);
var snSigKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNSigKey);
var snPubSigKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNSigPubKey);
using (var ms = new MemoryStream()) {
var options = new ModuleWriterOptions(stubModule)
{
StrongNameKey = snKey,
StrongNamePublicKey = snPubKey,
DelaySign = snDelaySig
};
var injector = new KeyInjector(ctx);
options.WriterEvent += injector.WriterEvent;
stubModule.Write(ms, options);
context.CheckCancellation();
ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, snPubKey, snSigKey, snPubKey, snDelaySig, new StubProtection(ctx, originModule));
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
for (int i = 1; i < 1; i++)
{
foreach (IDnlibDef dnlibDef in parameters.Targets)
{
MethodDef def = (MethodDef)dnlibDef;
CilBody body = def.Body;
body.SimplifyBranches();
Random random = new Random();
int num2 = 0;
while (num2 < body.Instructions.Count)
{
if (body.Instructions[num2].IsLdcI4())
{
int num3 = body.Instructions[num2].GetLdcI4Value();
int num4 = random.Next(5, 40);
body.Instructions[num2].OpCode = OpCodes.Ldc_I4;
body.Instructions[num2].Operand = num4 * num3;
body.Instructions.Insert(num2 + 1, Instruction.Create(OpCodes.Ldc_I4, num4));
body.Instructions.Insert(num2 + 2, Instruction.Create(OpCodes.Div));
num2 += 3;
}
else
{
num2++;
}
}
Random random2 = new Random();
int num5 = 0;
ITypeDefOrRef type = null;
for (int j = 0; j < def.Body.Instructions.Count; j++)
{
Instruction instruction = def.Body.Instructions[j];
if (instruction.IsLdcI4())
{
switch (random2.Next(1, 8))
{
case 1:
type = def.Module.Import(typeof(int));
num5 = 4;
break;
case 2:
type = def.Module.Import(typeof(sbyte));
num5 = 1;
break;
case 3:
type = def.Module.Import(typeof(byte));
num5 = 1;
break;
case 4:
type = def.Module.Import(typeof(bool));
num5 = 1;
break;
case 5:
type = def.Module.Import(typeof(decimal));
num5 = 16;
break;
case 6:
type = def.Module.Import(typeof(short));
num5 = 2;
break;
case 7:
type = def.Module.Import(typeof(long));
num5 = 8;
break;
}
int num6 = random2.Next(1, 1000);
bool flag = Convert.ToBoolean(random2.Next(0, 2));
switch ((num5 != 0) ? ((Convert.ToInt32(instruction.Operand) % num5 == 0) ? random2.Next(1, 5) : random2.Next(1, 4)) : random2.Next(1, 4))
{
case 1:
def.Body.Instructions.Insert(j + 1, Instruction.Create(OpCodes.Sizeof, type));
def.Body.Instructions.Insert(j + 2, Instruction.Create(OpCodes.Add));
instruction.Operand = Convert.ToInt32(instruction.Operand) - num5 + (flag ? (-num6) : num6);
goto IL_43A;
case 2:
def.Body.Instructions.Insert(j + 1, Instruction.Create(OpCodes.Sizeof, type));
def.Body.Instructions.Insert(j + 2, Instruction.Create(OpCodes.Sub));
instruction.Operand = Convert.ToInt32(instruction.Operand) + num5 + (flag ? (-num6) : num6);
goto IL_43A;
case 3:
def.Body.Instructions.Insert(j + 1, Instruction.Create(OpCodes.Sizeof, type));
def.Body.Instructions.Insert(j + 2, Instruction.Create(OpCodes.Add));
instruction.Operand = Convert.ToInt32(instruction.Operand) - num5 + (flag ? (-num6) : num6);
goto IL_43A;
case 4:
def.Body.Instructions.Insert(j + 1, Instruction.Create(OpCodes.Sizeof, type));
def.Body.Instructions.Insert(j + 2, Instruction.Create(OpCodes.Mul));
instruction.Operand = Convert.ToInt32(instruction.Operand) / num5;
break;
default:
goto IL_43A;
}
IL_484:
j += 2;
goto IL_48A;
IL_43A:
def.Body.Instructions.Insert(j + 3, Instruction.CreateLdcI4(num6));
def.Body.Instructions.Insert(j + 4, Instruction.Create(flag ? OpCodes.Add : OpCodes.Sub));
j += 2;
goto IL_484;
}
IL_48A :;
}
body.OptimizeBranches();
}
}
}
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.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);
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var moduleCtx = context.Annotations.Get <CEContext>(context.CurrentModule, ConstantProtection.ContextKey);
if (!parameters.Targets.Any() || moduleCtx == null)
{
return;
}
var ldc = new Dictionary <object, List <Tuple <MethodDef, Instruction> > >();
var ldInit = new Dictionary <byte[], List <Tuple <MethodDef, Instruction> > >(new ByteArrayComparer());
// Extract constants
ExtractConstants(context, parameters, moduleCtx, ldc, ldInit);
// Encode constants
moduleCtx.ReferenceRepl = new Dictionary <MethodDef, List <Tuple <Instruction, uint, IMethod> > >();
moduleCtx.EncodedBuffer = new List <uint>();
foreach (var entry in ldInit.WithProgress(context.Logger)) // Ensure the array length haven't been encoded yet
{
EncodeInitializer(moduleCtx, entry.Key, entry.Value);
context.CheckCancellation();
}
foreach (var entry in ldc.WithProgress(context.Logger))
{
if (entry.Key is string)
{
EncodeString(moduleCtx, (string)entry.Key, entry.Value);
}
else if (entry.Key is int)
{
EncodeConstant32(moduleCtx, (uint)(int)entry.Key, context.CurrentModule.CorLibTypes.Int32, entry.Value);
}
else if (entry.Key is long)
{
EncodeConstant64(moduleCtx, (uint)((long)entry.Key >> 32), (uint)(long)entry.Key, context.CurrentModule.CorLibTypes.Int64, entry.Value);
}
else if (entry.Key is float)
{
var t = new RTransform();
t.R4 = (float)entry.Key;
EncodeConstant32(moduleCtx, t.Hi, context.CurrentModule.CorLibTypes.Single, entry.Value);
}
else if (entry.Key is double)
{
var t = new RTransform();
t.R8 = (double)entry.Key;
EncodeConstant64(moduleCtx, t.Hi, t.Lo, context.CurrentModule.CorLibTypes.Double, entry.Value);
}
else
{
throw new UnreachableException();
}
context.CheckCancellation();
}
ReferenceReplacer.ReplaceReference(moduleCtx, parameters);
// compress
var encodedBuff = new byte[moduleCtx.EncodedBuffer.Count * 4];
int buffIndex = 0;
foreach (uint dat in moduleCtx.EncodedBuffer)
{
encodedBuff[buffIndex++] = (byte)((dat >> 0) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 8) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 16) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 24) & 0xff);
}
Debug.Assert(buffIndex == encodedBuff.Length);
encodedBuff = context.Registry.GetService <ICompressionService>().Compress(encodedBuff);
context.CheckCancellation();
uint compressedLen = (uint)(encodedBuff.Length + 3) / 4;
compressedLen = (compressedLen + 0xfu) & ~0xfu;
var compressedBuff = new uint[compressedLen];
Buffer.BlockCopy(encodedBuff, 0, compressedBuff, 0, encodedBuff.Length);
Debug.Assert(compressedLen % 0x10 == 0);
// encrypt
uint keySeed = moduleCtx.Random.NextUInt32();
var key = new uint[0x10];
uint state = keySeed;
for (int i = 0; i < 0x10; i++)
{
state ^= state >> 12;
state ^= state << 25;
state ^= state >> 27;
key[i] = state;
}
var encryptedBuffer = new byte[compressedBuff.Length * 4];
buffIndex = 0;
while (buffIndex < compressedBuff.Length)
{
uint[] enc = moduleCtx.ModeHandler.Encrypt(compressedBuff, buffIndex, key);
for (int j = 0; j < 0x10; j++)
{
key[j] ^= compressedBuff[buffIndex + j];
}
Buffer.BlockCopy(enc, 0, encryptedBuffer, buffIndex * 4, 0x40);
buffIndex += 0x10;
}
Debug.Assert(buffIndex == compressedBuff.Length);
moduleCtx.DataField.InitialValue = encryptedBuffer;
moduleCtx.DataField.HasFieldRVA = true;
moduleCtx.DataType.ClassLayout = new ClassLayoutUser(0, (uint)encryptedBuffer.Length);
MutationHelper.InjectKeys(moduleCtx.InitMethod,
new[] { 0, 1 },
new[] { encryptedBuffer.Length / 4, (int)keySeed });
MutationHelper.ReplacePlaceholder(moduleCtx.InitMethod, arg => {
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Dup));
repl.Add(Instruction.Create(OpCodes.Ldtoken, moduleCtx.DataField));
repl.Add(Instruction.Create(OpCodes.Call, moduleCtx.Module.Import(
typeof(RuntimeHelpers).GetMethod("InitializeArray"))));
return(repl.ToArray());
});
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
foreach (ModuleDef moduleDef in parameters.Targets.OfType <ModuleDef>())
{
foreach (TypeDef typeDef in moduleDef.Types)
{
foreach (MethodDef methodDef in typeDef.Methods)
{
if (methodDef.HasBody && methodDef.Body.HasInstructions)
{
for (int i = 0; i < methodDef.Body.Instructions.Count; i++)
{
if (methodDef.Body.Instructions[i].IsLdcI4())
{
// EmptyType
int operand = methodDef.Body.Instructions[i].GetLdcI4Value();
methodDef.Body.Instructions[i].Operand = operand - Type.EmptyTypes.Length;
methodDef.Body.Instructions[i].OpCode = OpCodes.Ldc_I4;
methodDef.Body.Instructions.Insert(i + 1, OpCodes.Ldsfld.ToInstruction(methodDef.Module.Import(typeof(Type).GetField("EmptyTypes"))));
methodDef.Body.Instructions.Insert(i + 2, Instruction.Create(OpCodes.Ldlen));
methodDef.Body.Instructions.Insert(i + 3, Instruction.Create(OpCodes.Add));
body = methodDef.Body;
int ldcI4Value = body.Instructions[i].GetLdcI4Value();
int num = rnd.Next(1, 4);
int num2 = ldcI4Value - num;
body.Instructions[i].Operand = num2;
Mutate(i, num, num2, moduleDef);
// Double Parse
int operand3 = methodDef.Body.Instructions[i].GetLdcI4Value();
double n = RandomDouble(1.0, 1000.0);
string converter = Convert.ToString(n);
double nEw = double.Parse(converter);
int conta = operand3 - (int)nEw;
methodDef.Body.Instructions[i].Operand = conta;
methodDef.Body.Instructions[i].OpCode = OpCodes.Ldc_I4;
methodDef.Body.Instructions.Insert(i + 1, Instruction.Create(OpCodes.Ldstr, converter));
methodDef.Body.Instructions.Insert(i + 2, OpCodes.Call.ToInstruction(methodDef.Module.Import(typeof(double).GetMethod("Parse", new Type[] { typeof(string) }))));
methodDef.Body.Instructions.Insert(i + 3, OpCodes.Conv_I4.ToInstruction());
methodDef.Body.Instructions.Insert(i + 4, Instruction.Create(OpCodes.Add));
// Calc
int op = methodDef.Body.Instructions[i].GetLdcI4Value();
int newvalue = rnd.Next(-100, 10000);
switch (rnd.Next(1, 4))
{
case 1:
methodDef.Body.Instructions[i].Operand = op - newvalue;
methodDef.Body.Instructions.Insert(i + 1, OpCodes.Ldc_I4.ToInstruction(newvalue));
methodDef.Body.Instructions.Insert(i + 2, OpCodes.Add.ToInstruction());
i += 2;
break;
case 2:
methodDef.Body.Instructions[i].Operand = op + newvalue;
methodDef.Body.Instructions.Insert(i + 1, OpCodes.Ldc_I4.ToInstruction(newvalue));
methodDef.Body.Instructions.Insert(i + 2, OpCodes.Sub.ToInstruction());
i += 2;
break;
case 3:
methodDef.Body.Instructions[i].Operand = op ^ newvalue;
methodDef.Body.Instructions.Insert(i + 1, OpCodes.Ldc_I4.ToInstruction(newvalue));
methodDef.Body.Instructions.Insert(i + 2, OpCodes.Xor.ToInstruction());
i += 2;
break;
case 4:
int operand2 = methodDef.Body.Instructions[i].GetLdcI4Value();
methodDef.Body.Instructions[i].OpCode = OpCodes.Ldc_I4;
methodDef.Body.Instructions[i].Operand = operand2 - 1;
int valor = rnd.Next(100, 500);
int valor2 = rnd.Next(1000, 5000);
methodDef.Body.Instructions.Insert(i + 1, Instruction.CreateLdcI4(valor));
methodDef.Body.Instructions.Insert(i + 2, Instruction.CreateLdcI4(valor2));
methodDef.Body.Instructions.Insert(i + 3, Instruction.Create(OpCodes.Clt));
methodDef.Body.Instructions.Insert(i + 4, Instruction.Create(OpCodes.Conv_I4));
methodDef.Body.Instructions.Insert(i + 5, Instruction.Create(OpCodes.Add));
i += 5;
break;
}
}
}
}
}
}
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var service = (NameService)context.Registry.GetService <INameService>();
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.RandomName();
pdbDocs.Add(instr.SequencePoint.Document.Url);
}
}
foreach (var local in method.Body.Variables)
{
if (!string.IsNullOrEmpty(local.Name))
{
local.Name = service.RandomName();
}
}
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.RandomName();
typeDef.Namespace = service.RandomName();
}
else if (parameters.GetParameter(context, def, "resource", true))
{
continue;
}
else
{
typeDef.Namespace = service.RandomName();
typeDef.Name = service.RandomName();
}
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.RandomName();
}
else
{
def.Name = service.RandomName();
}
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 MarkMember(IDnlibDef member, ConfuserContext context)
{
ModuleDef module = ((IMemberRef)member).Module;
ProtectionParameters.SetParameters(context, member, ProtectionParameters.GetParameters(context, module));
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDef;
if (module == null)
{
return;
}
string asmName = module.Assembly.Name.String;
if (!string.IsNullOrEmpty(module.Assembly.Culture) &&
asmName.EndsWith(".resources"))
{
// Satellite assembly
string satellitePattern = $"^(.*)\\.(?i:({module.Assembly.Culture}))\\.resources$";
string nameAsmName = asmName.Substring(0, asmName.Length - ".resources".Length);
ModuleDef mainModule = context.Modules.SingleOrDefault(mod => mod.Assembly.Name == nameAsmName);
if (mainModule == null)
{
context.Logger.ErrorFormat("Could not find main assembly of satellite assembly '{0}'.", module.Assembly.FullName);
throw new ConfuserException(null);
}
foreach (Resource res in module.Resources)
{
Match match = Regex.Match(res.Name, satellitePattern);
if (!match.Success)
{
continue;
}
string typeName = match.Groups[1].Value;
string culture = match.Groups[2].Value;
TypeDef type = mainModule.FindReflection(typeName);
if (type == null)
{
context.Logger.WarnFormat(Resources.ResourceAnalyzer_Analyze_CouldNotFindResourceType, typeName);
continue;
}
string format = $"{{0}}.{culture}.resources";
service.ReduceRenameMode(type, RenameMode.Reflection);
service.AddReference(type, new ResourceReference(res, type, format));
}
}
else
{
string format = "{0}.resources";
foreach (Resource res in module.Resources)
{
Match match = ResourceNamePattern.Match(res.Name);
if (!match.Success || res.ResourceType != ResourceType.Embedded)
{
continue;
}
string typeName = match.Groups[1].Value;
if (typeName.EndsWith(".g")) // WPF resources, ignore
{
continue;
}
// This variable is set true in case the name of the resource doesn't match the name of the class.
// That happens for the resources in Visual Basic.
var mismatchingName = false;
TypeDef type = module.FindReflection(typeName);
if (type == null)
{
if (typeName.EndsWith(".Resources"))
{
typeName = typeName.Substring(0, typeName.Length - 10) + ".My.Resources.Resources";
type = module.FindReflection(typeName);
mismatchingName = type != null;
}
}
if (type == null)
{
context.Logger.WarnFormat(Resources.ResourceAnalyzer_Analyze_CouldNotFindResourceType, typeName);
continue;
}
service.ReduceRenameMode(type, RenameMode.Reflection);
service.AddReference(type, new ResourceReference(res, type, format));
if (mismatchingName)
{
// Add string type references in case the name didn't match. This will cause the resource to get
// the same name as the class, despite that not being the case before. But that doesn't really matter.
FindLdTokenResourceReferences(type, match.Groups[1].Value, service);
}
}
}
}
protected internal override void Execute(DotProtectContext 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("DotProtect.Runtime.AntiDebugSafe");
break;
case AntiMode.Win32:
rtType = rt.GetRuntimeType("DotProtect.Runtime.AntiDebugWin32");
break;
case AntiMode.Antinet:
rtType = rt.GetRuntimeType("DotProtect.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(ConfuserContext context, INameService service, MethodDef method, ProtectionParameters parameters)
{
if (GetJsonContainerAttribute(method.DeclaringType) != null && method.IsConstructor)
{
service.SetParam(method, "renameArgs", "false");
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var method = def as MethodDef;
if (method == null || !method.HasBody)
{
return;
}
// When a ldtoken instruction reference a definition,
// most likely it would be used in reflection and thus probably should not be renamed.
// Also, when ToString is invoked on enum,
// the enum should not be renamed.
for (int i = 0; i < method.Body.Instructions.Count; i++)
{
Instruction instr = method.Body.Instructions[i];
if (instr.OpCode.Code == Code.Ldtoken)
{
if (instr.Operand is MemberRef)
{
IMemberForwarded member = ((MemberRef)instr.Operand).ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)member.Module))
{
service.SetCanRename(member, false);
}
}
else if (instr.Operand is IField)
{
FieldDef field = ((IField)instr.Operand).ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)field.Module))
{
service.SetCanRename(field, false);
}
}
else if (instr.Operand is IMethod)
{
var im = (IMethod)instr.Operand;
if (!im.IsArrayAccessors())
{
MethodDef m = im.ResolveThrow();
if (context.Modules.Contains((ModuleDefMD)m.Module))
{
service.SetCanRename(method, false);
}
}
}
else if (instr.Operand is ITypeDefOrRef)
{
if (!(instr.Operand is TypeSpec))
{
TypeDef type = ((ITypeDefOrRef)instr.Operand).ResolveTypeDefThrow();
if (context.Modules.Contains((ModuleDefMD)type.Module) &&
HandleTypeOf(context, service, method, i))
{
var t = type;
do
{
DisableRename(service, t, false);
t = t.DeclaringType;
} while (t != null);
}
}
}
else
{
throw new UnreachableException();
}
}
else if ((instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) &&
((IMethod)instr.Operand).Name == "ToString")
{
HandleEnum(context, service, method, i);
}
else if (instr.OpCode.Code == Code.Ldstr)
{
TypeDef typeDef = method.Module.FindReflection((string)instr.Operand);
if (typeDef != null)
{
service.AddReference(typeDef, new StringTypeReference(instr, typeDef));
}
}
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDef;
if (module == null)
{
return;
}
string asmName = module.Assembly.Name.String;
if (!string.IsNullOrEmpty(module.Assembly.Culture) &&
asmName.EndsWith(".resources"))
{
// Satellite assembly
var satellitePattern = new Regex(string.Format("^(.*)\\.{0}\\.resources$", module.Assembly.Culture));
string nameAsmName = asmName.Substring(0, asmName.Length - ".resources".Length);
ModuleDef mainModule = context.Modules.SingleOrDefault(mod => mod.Assembly.Name == nameAsmName);
if (mainModule == null)
{
context.Logger.ErrorFormat("Could not find main assembly of satellite assembly '{0}'.", module.Assembly.FullName);
throw new ConfuserException(null);
}
string format = "{0}." + module.Assembly.Culture + ".resources";
foreach (Resource res in module.Resources)
{
Match match = satellitePattern.Match(res.Name);
if (!match.Success)
{
continue;
}
string typeName = match.Groups[1].Value;
TypeDef type = mainModule.FindReflection(typeName);
if (type == null)
{
context.Logger.WarnFormat("Could not find resource type '{0}'.", typeName);
continue;
}
service.ReduceRenameMode(type, RenameMode.ASCII);
service.AddReference(type, new ResourceReference(res, type, format));
}
}
else
{
string format = "{0}.resources";
foreach (Resource res in module.Resources)
{
Match match = ResourceNamePattern.Match(res.Name);
if (!match.Success || res.ResourceType != ResourceType.Embedded)
{
continue;
}
string typeName = match.Groups[1].Value;
if (typeName.EndsWith(".g")) // WPF resources, ignore
{
continue;
}
TypeDef type = module.FindReflection(typeName);
if (type == null)
{
if (typeName.EndsWith(".Resources"))
{
typeName = typeName.Substring(0, typeName.Length - 10) + ".My.Resources.Resources";
type = module.FindReflection(typeName);
}
}
if (type == null)
{
context.Logger.WarnFormat("Could not find resource type '{0}'.", typeName);
continue;
}
service.ReduceRenameMode(type, RenameMode.ASCII);
service.AddReference(type, new ResourceReference(res, type, format));
}
}
}
public void HandleMD(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters)
{
methods = parameters.Targets.OfType <MethodDef>().Where(method => method.HasBody).ToList();
context.CurrentModuleWriterListener.OnWriterEvent += OnWriterEvent;
}
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;
}
}
}
}
}
void ParseParameters(IDnlibDef def, ConfuserContext context, NameService service, ProtectionParameters parameters)
{
RenameMode?mode = parameters.GetParameter <RenameMode?>(context, def, "mode", null);
if (mode != null)
{
service.SetRenameMode(def, mode.Value);
}
}
void Analyze(ConfuserContext context, INameService service, PropertyDef property, ProtectionParameters parameters)
{
if (ShouldExclude(property.DeclaringType, property))
{
service.SetCanRename(property, false);
}
}
public void PostRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDefMD;
if (module == null)
{
return;
}
var wpfResInfo = context.Annotations.Get <Dictionary <string, Dictionary <string, BamlDocument> > >(module, BAMLKey);
if (wpfResInfo == null)
{
return;
}
var newResources = new List <EmbeddedResource>();
foreach (EmbeddedResource res in module.Resources.OfType <EmbeddedResource>())
{
Dictionary <string, BamlDocument> resInfo;
if (!wpfResInfo.TryGetValue(res.Name, out resInfo))
{
continue;
}
var stream = new MemoryStream();
var writer = new ResourceWriter(stream);
var reader = new ResourceReader(res.CreateReader().AsStream());
IDictionaryEnumerator enumerator = reader.GetEnumerator();
while (enumerator.MoveNext())
{
var name = (string)enumerator.Key;
string typeName;
byte[] data;
reader.GetResourceData(name, out typeName, out data);
BamlDocument document;
if (resInfo.TryGetValue(name, out document))
{
var docStream = new MemoryStream();
docStream.Position = 4;
BamlWriter.WriteDocument(document, docStream);
docStream.Position = 0;
docStream.Write(BitConverter.GetBytes((int)docStream.Length - 4), 0, 4);
data = docStream.ToArray();
name = document.DocumentName;
}
writer.AddResourceData(name, typeName, data);
}
writer.Generate();
newResources.Add(new EmbeddedResource(res.Name, stream.ToArray(), res.Attributes));
}
foreach (EmbeddedResource res in newResources)
{
int index = module.Resources.IndexOfEmbeddedResource(res.Name);
module.Resources[index] = res;
}
}
// Token: 0x06000032 RID: 50 RVA: 0x000041C0 File Offset: 0x000023C0
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
if (def is TypeDef)
{
TypeDef type = (TypeDef)def;
if (type.IsInterface)
{
return;
}
VTable vTbl = service.GetVTables()[type];
using (IEnumerator <IList <VTableSlot> > enumerator = vTbl.InterfaceSlots.Values.GetEnumerator())
{
while (enumerator.MoveNext())
{
IList <VTableSlot> ifaceVTbl = enumerator.Current;
foreach (VTableSlot slot in ifaceVTbl)
{
if (slot.Overrides != null)
{
bool baseUnderCtrl = context.Modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool ifaceUnderCtrl = context.Modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if ((!baseUnderCtrl && ifaceUnderCtrl) || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if ((baseUnderCtrl && !ifaceUnderCtrl) || !service.CanRename(slot.Overrides.MethodDef))
{
service.SetCanRename(slot.MethodDef, false);
}
}
}
}
return;
}
}
if (def is MethodDef)
{
MethodDef method = (MethodDef)def;
if (!method.IsVirtual)
{
return;
}
VTable vTbl = service.GetVTables()[method.DeclaringType];
VTableSignature.FromMethod(method);
IEnumerable <VTableSlot> slots = vTbl.FindSlots(method);
if (!method.IsAbstract)
{
using (IEnumerator <VTableSlot> enumerator3 = slots.GetEnumerator())
{
while (enumerator3.MoveNext())
{
VTableSlot slot2 = enumerator3.Current;
if (slot2.Overrides != null)
{
service.AddReference <MethodDef>(method, new OverrideDirectiveReference(slot2, slot2.Overrides));
service.AddReference <MethodDef>(slot2.Overrides.MethodDef, new OverrideDirectiveReference(slot2, slot2.Overrides));
}
}
return;
}
}
foreach (VTableSlot slot3 in slots)
{
if (slot3.Overrides != null)
{
service.SetCanRename(method, false);
service.SetCanRename(slot3.Overrides.MethodDef, 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);
}
public void ExcludeMethod(ConfuserContext context, MethodDef method)
{
ProtectionParameters.GetParameters(context, method).Remove(this);
}
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.Expression);
ret.InternalAlso = parameters.GetParameter(context, method, "internal", true);
ret.TypeErasure = parameters.GetParameter(context, method, "typeErasure", true);
ret.Depth = parameters.GetParameter(context, method, "depth", 7);
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 = (MildReferenceProxyProtection)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 <NameService>();
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);
}
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;
}
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, context.CurrentModule, "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);
}
}
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();
}
}
