TypeDef GetKeyAttr(RPContext ctx)
{
if (keyAttrs == null)
{
keyAttrs = new Tuple <TypeDef, Func <int, int> > [0x10];
}
int index = ctx.Random.NextInt32(keyAttrs.Length);
if (keyAttrs[index] == null)
{
TypeDef rtType = ctx.Context.Registry.GetService <IRuntimeService>().GetRuntimeType("Confuser.Runtime.RefProxyKey");
TypeDef injectedAttr = InjectHelper.Inject(rtType, ctx.Module);
injectedAttr.Name = ctx.Name.RandomName();
injectedAttr.Namespace = string.Empty;
Expression expression, inverse;
var var = new Variable("{VAR}");
var result = new Variable("{RESULT}");
ctx.DynCipher.GenerateExpressionPair(
ctx.Random,
new VariableExpression {
Variable = var
}, new VariableExpression {
Variable = result
},
ctx.Depth, out expression, out inverse);
var expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile <Func <int, int> >();
MethodDef ctor = injectedAttr.FindMethod(".ctor");
MutationHelper.ReplacePlaceholder(ctor, arg =>
{
var invCompiled = new List <Instruction>();
new CodeGen(arg, ctor, invCompiled).GenerateCIL(inverse);
return(invCompiled.ToArray());
});
keyAttrs[index] = Tuple.Create(injectedAttr, expCompiled);
ctx.Module.AddAsNonNestedType(injectedAttr);
foreach (IDnlibDef def in injectedAttr.FindDefinitions())
{
if (def.Name == "GetHashCode")
{
ctx.Name.MarkHelper(def, ctx.Marker, ctx.Protection);
((MethodDef)def).Access = MethodAttributes.Public;
}
else
{
ctx.Name.MarkHelper(def, ctx.Marker, ctx.Protection);
}
}
}
return(keyAttrs[index].Item1);
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var rt = context.Registry.GetService <IRuntimeService>();
var marker = context.Registry.GetService <IMarkerService>();
var name = context.Registry.GetService <INameService>();
foreach (var module in parameters.Targets.OfType <ModuleDef>())
{
var mode = parameters.GetParameter(context, module, "mode", AntiMode.Safe);
TypeDef rtType;
TypeDef attr = null;
const string attrName = "System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute";
switch (mode)
{
case AntiMode.Safe:
rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugSafe");
break;
case AntiMode.Win32:
rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugWin32");
break;
case AntiMode.Antinet:
rtType = rt.GetRuntimeType("Confuser.Runtime.AntiDebugAntinet");
attr = rt.GetRuntimeType(attrName);
module.Types.Add(attr = InjectHelper.Inject(attr, module));
foreach (var member in attr.FindDefinitions())
{
marker.Mark(member, (Protection)Parent);
name.Analyze(member);
}
name.SetCanRename(attr, false);
break;
default:
throw new UnreachableException();
}
var members = InjectHelper.Inject(rtType, module.GlobalType, module);
var cctor = module.GlobalType.FindStaticConstructor();
var init = (MethodDef)members.Single(method => method.Name == "Initialize");
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
foreach (var member in members)
{
marker.Mark(member, (Protection)Parent);
name.Analyze(member);
var 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;
}
var 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);
}
}
}
}
