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