public bool CanRename(object obj)
{
if (obj is IDnlibDef)
{
if (analyze == null)
{
analyze = context.Pipeline.FindPhase <AnalyzePhase>();
}
var prot = (NameProtection)analyze.Parent;
ProtectionSettings parameters = ProtectionParameters.GetParameters(context, (IDnlibDef)obj);
if (parameters == null || !parameters.ContainsKey(prot))
{
return(false);
}
return(context.Annotations.Get(obj, CanRenameKey, true));
}
return(false);
}
private void RerouteEntrypoint(ITypeService service, ConfuserContext context)
{
var originalEntry = context.CurrentModule.EntryPoint;
if (originalEntry != null)
{
originalEntry.Name = "_start";
var param = originalEntry.Parameters.FirstOrDefault()?.Type;
var newEntry = new MethodDefUser("Main",
originalEntry.MethodSig,
originalEntry.ImplAttributes, originalEntry.Attributes);
IMethod callSig = originalEntry;
var scannedEntry = service.GetScannedItem(originalEntry);
if (scannedEntry != null)
{
callSig = new MethodSpecUser(originalEntry, new GenericInstMethodSig(scannedEntry.GenericCallTypes.ToArray()));
}
newEntry.Body = new dnlib.DotNet.Emit.CilBody(false, new Instruction[] {
Instruction.Create(param == null ? OpCodes.Nop : OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Call, callSig),
Instruction.Create(OpCodes.Ret),
}, new ExceptionHandler[0], new LocalList());
originalEntry.DeclaringType.Methods.Add(newEntry);
context.CurrentModule.EntryPoint = newEntry;
ProtectionParameters.SetParameters(context, newEntry, ProtectionParameters.GetParameters(context, originalEntry));
service.RewriteMethodInstructions(newEntry);
}
}
void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, CEContext moduleCtx)
{
var members = InjectHelper.Inject(rt.GetRuntimeType("Confuser.Runtime.Constant"), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (var member in members)
{
if (member.Name == "Get")
{
context.CurrentModule.GlobalType.Remove((MethodDef)member);
continue;
}
if (member.Name == "b")
{
moduleCtx.BufferField = (FieldDef)member;
}
else if (member.Name == "Initialize")
{
moduleCtx.InitMethod = (MethodDef)member;
}
moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent);
}
ProtectionParameters.GetParameters(context, moduleCtx.InitMethod).Remove(Parent);
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"))
{
Layout = TypeAttributes.ExplicitLayout,
Visibility = TypeAttributes.NestedPrivate,
IsSealed = true
};
moduleCtx.DataType = dataType;
context.CurrentModule.GlobalType.NestedTypes.Add(dataType);
moduleCtx.Name.MarkHelper(dataType, moduleCtx.Marker, (Protection)Parent);
moduleCtx.DataField = new FieldDefUser(moduleCtx.Name.RandomName(), new FieldSig(dataType.ToTypeSig()))
{
IsStatic = true,
Access = FieldAttributes.CompilerControlled
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent);
var decoder = rt.GetRuntimeType("Confuser.Runtime.Constant").FindMethod("Get");
moduleCtx.Decoders = new List <Tuple <MethodDef, DecoderDesc> >();
for (var i = 0; i < moduleCtx.DecoderCount; i++)
{
var decoderInst = InjectHelper.Inject(decoder, context.CurrentModule);
for (var j = 0; j < decoderInst.Body.Instructions.Count; j++)
{
var instr = decoderInst.Body.Instructions[j];
var method = instr.Operand as IMethod;
var field = instr.Operand as IField;
if (instr.OpCode == OpCodes.Call &&
method.DeclaringType.Name == "Mutation" &&
method.Name == "Value")
{
decoderInst.Body.Instructions[j] = Instruction.Create(OpCodes.Sizeof, new GenericMVar(0).ToTypeDefOrRef());
}
else if (instr.OpCode == OpCodes.Ldsfld &&
method.DeclaringType.Name == "Constant")
{
if (field.Name == "b")
{
instr.Operand = moduleCtx.BufferField;
}
else
{
throw new UnreachableException();
}
}
}
context.CurrentModule.GlobalType.Methods.Add(decoderInst);
moduleCtx.Name.MarkHelper(decoderInst, moduleCtx.Marker, (Protection)Parent);
ProtectionParameters.GetParameters(context, decoderInst).Remove(Parent);
var decoderDesc = new DecoderDesc
{
StringID = (byte)(moduleCtx.Random.NextByte() & 3)
};
do
{
decoderDesc.NumberID = (byte)(moduleCtx.Random.NextByte() & 3);
}while (decoderDesc.NumberID == decoderDesc.StringID);
do
{
decoderDesc.InitializerID = (byte)(moduleCtx.Random.NextByte() & 3);
}while (decoderDesc.InitializerID == decoderDesc.StringID || decoderDesc.InitializerID == decoderDesc.NumberID);
MutationHelper.InjectKeys(decoderInst,
new[] { 0, 1, 2 },
new int[] { decoderDesc.StringID, decoderDesc.NumberID, decoderDesc.InitializerID });
decoderDesc.Data = moduleCtx.ModeHandler.CreateDecoder(decoderInst, moduleCtx);
moduleCtx.Decoders.Add(Tuple.Create(decoderInst, decoderDesc));
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
if (parameters.Targets.Any())
{
var compression = context.Registry.GetService <ICompressionService>();
var name = context.Registry.GetService <INameService>();
var marker = context.Registry.GetService <IMarkerService>();
var rt = context.Registry.GetService <IRuntimeService>();
var moduleCtx = new CEContext {
Protection = (ConstantProtection)Parent,
Random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Parent.Id),
Context = context,
Module = context.CurrentModule,
Marker = marker,
DynCipher = context.Registry.GetService <IDynCipherService>(),
Name = name
};
// Extract parameters
moduleCtx.Mode = parameters.GetParameter(context, context.CurrentModule, "mode", Mode.Normal);
moduleCtx.DecoderCount = parameters.GetParameter(context, context.CurrentModule, "decoderCount", 5);
switch (moduleCtx.Mode)
{
case Mode.Normal:
moduleCtx.ModeHandler = new NormalMode();
break;
case Mode.Dynamic:
moduleCtx.ModeHandler = new DynamicMode();
break;
case Mode.x86:
moduleCtx.ModeHandler = new x86Mode();
if ((context.CurrentModule.Cor20HeaderFlags & ComImageFlags.ILOnly) != 0)
{
context.CurrentModuleWriterOptions.Cor20HeaderOptions.Flags &= ~ComImageFlags.ILOnly;
}
break;
default:
throw new UnreachableException();
}
// Inject helpers
var decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member => {
name.MarkHelper(member, marker, (Protection)Parent);
if (member is MethodDef)
{
ProtectionParameters.GetParameters(context, member).Remove(Parent);
}
});
InjectHelpers(context, compression, rt, moduleCtx);
// Mutate codes
MutateInitializer(moduleCtx, decomp);
var cctor = context.CurrentModule.GlobalType.FindStaticConstructor();
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod));
context.Annotations.Set(context.CurrentModule, ConstantProtection.ContextKey, moduleCtx);
}
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
context.Logger.Log("Initializing DarksVM");
foreach (ModuleDefMD module in context.Modules)
{
context.Logger.LogFormat("Protecting '{0}' with DarksVM...", module.Name);
}
var random = context.Registry.GetService <IRandomService>();
var refProxy = context.Registry.GetService <IReferenceProxyService>();
var nameSrv = context.Registry.GetService <INameService>();
var seed = random.GetRandomGenerator(Parent.FullId).NextInt32();
string rtName = null;
bool dbg = false, stackwalk = false;
ModuleDef merge = null;
foreach (var module in context.Modules)
{
if (rtName == null)
{
rtName = parameters.GetParameter <string>(context, module, "rtName");
}
if (dbg == false)
{
dbg = parameters.GetParameter <bool>(context, module, "dbgInfo");
}
if (stackwalk == false)
{
stackwalk = parameters.GetParameter <bool>(context, module, "stackwalk");
}
merge = module;
rtName = "Virtualization";
}
rtName = rtName ?? "KoiVM.Runtime--test";
ModuleDefMD rtModule;
var resStream = typeof(Virtualizer).Assembly.GetManifestResourceStream("KoiVM.Runtime.dll");
if (resStream != null)
{
rtModule = ModuleDefMD.Load(resStream, context.Resolver.DefaultModuleContext);
}
else
{
var rtPath = Path.Combine(koiDir, "KoiVM.Runtime.dll");
rtModule = ModuleDefMD.Load(rtPath, context.Resolver.DefaultModuleContext);
}
rtModule.Assembly.Name = rtName;
rtModule.Name = rtName + ".dll";
var vr = new Virtualizer(seed, context.Project.Debug);
vr.ExportDbgInfo = dbg;
vr.DoStackWalk = stackwalk;
vr.Initialize(rtModule);
context.Annotations.Set(context, Fish.VirtualizerKey, vr);
context.Annotations.Set(context, Fish.MergeKey, merge);
if (merge != null)
{
var types = new List <TypeDef>(vr.RuntimeModule.GetTypes());
types.Remove(vr.RuntimeModule.GlobalType);
vr.CommitRuntime(merge);
foreach (var type in types)
{
foreach (var def in type.FindDefinitions())
{
if (def is TypeDef && def != type) // nested type
{
continue;
}
nameSrv.SetCanRename(def, false);
ProtectionParameters.SetParameters(context, def, new ProtectionSettings());
}
}
}
else
{
vr.CommitRuntime(merge);
}
var ctor = typeof(InternalsVisibleToAttribute).GetConstructor(new[] { typeof(string) });
foreach (ModuleDef module in context.Modules)
{
var methods = new HashSet <MethodDef>();
foreach (var type in module.GetTypes())
{
foreach (var method in type.Methods)
{
if (ProtectionParameters.GetParameters(context, method).ContainsKey(Parent))
{
methods.Add(method);
}
}
}
if (methods.Count > 0)
{
var ca = new CustomAttribute((ICustomAttributeType)module.Import(ctor));
ca.ConstructorArguments.Add(new CAArgument(module.CorLibTypes.String, vr.RuntimeModule.Assembly.Name.String));
module.Assembly.CustomAttributes.Add(ca);
}
foreach (var entry in new Scanner(module, methods).Scan().WithProgress(context.Logger))
{
if (entry.Item2)
{
context.Annotations.Set(entry.Item1, Fish.ExportKey, Fish.ExportKey);
}
else
{
refProxy.ExcludeTarget(context, entry.Item1);
}
context.CheckCancellation();
}
}
}
public void ExcludeMethod(ConfuserContext context, MethodDef method)
{
ProtectionParameters.GetParameters(context, method).Remove(this);
}
/// <inheritdoc />
public bool IsMarked(IDnlibDef def)
{
return(ProtectionParameters.GetParameters(context, def) != null);
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
if (parameters.Targets.Any())
{
if (!UTF8String.IsNullOrEmpty(context.CurrentModule.Assembly.Culture))
{
context.Logger.DebugFormat("Skipping resource encryption for satellite assembly '{0}'.",
context.CurrentModule.Assembly.FullName);
return;
}
var compression = context.Registry.GetService <ICompressionService>();
var name = context.Registry.GetService <INameService>();
var marker = context.Registry.GetService <IMarkerService>();
var rt = context.Registry.GetService <IRuntimeService>();
var moduleCtx = new REContext
{
Random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Parent.Id),
Context = context,
Module = context.CurrentModule,
Marker = marker,
DynCipher = context.Registry.GetService <IDynCipherService>(),
Name = name
};
// Extract parameters
moduleCtx.Mode = parameters.GetParameter(context, context.CurrentModule, "mode", Mode.Normal);
switch (moduleCtx.Mode)
{
case Mode.Normal:
moduleCtx.ModeHandler = new NormalMode();
break;
case Mode.Dynamic:
moduleCtx.ModeHandler = new DynamicMode();
break;
default:
throw new UnreachableException();
}
// Inject helpers
var decomp = compression.GetRuntimeDecompressor(context.CurrentModule, member =>
{
name.MarkHelper(member, marker, (Protection)Parent);
if (member is MethodDef)
{
ProtectionParameters.GetParameters(context, member).Remove(Parent);
}
});
InjectHelpers(context, compression, rt, moduleCtx);
// Mutate codes
MutateInitializer(moduleCtx, decomp);
var cctor = context.CurrentModule.GlobalType.FindStaticConstructor();
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, moduleCtx.InitMethod));
new MDPhase(moduleCtx).Hook();
}
}
protected override void MarkMember(IDnlibDef member, ConfuserContext context)
{
ModuleDef module = ((IMemberRef)member).Module;
ProtectionParameters.SetParameters(context, member, ProtectionParameters.GetParameters(context, module));
}