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);
}
public void Init(ConfuserContext ctx, RandomGenerator random) {
StatementBlock dummy;
ctx.Registry.GetService<IDynCipherService>().GenerateCipherPair(random, out derivation, out dummy);
var dmCodeGen = new DMCodeGen(typeof(void), new[] {
Tuple.Create("{BUFFER}", typeof(uint[])),
Tuple.Create("{KEY}", typeof(uint[]))
});
dmCodeGen.GenerateCIL(derivation);
encryptFunc = dmCodeGen.Compile<Action<uint[], uint[]>>();
}
public void Init(ConfuserContext ctx, RandomGenerator random)
{
ctx.Registry.GetService <IDynCipherService>().GenerateCipherPair(random, out derivation, out var dummy);
var dmCodeGen = new DMCodeGen(typeof(void), new[] {
Tuple.Create("{BUFFER}", typeof(uint[])),
Tuple.Create("{KEY}", typeof(uint[]))
});
dmCodeGen.GenerateCIL(derivation);
encryptFunc = dmCodeGen.Compile <Action <uint[], uint[]> >();
}
void Compile(RPContext ctx, CilBody body, out Func<int, int> expCompiled, out Expression inverse) {
var var = new Variable("{VAR}");
var result = new Variable("{RESULT}");
Expression expression;
ctx.DynCipher.GenerateExpressionPair(
ctx.Random,
new VariableExpression { Variable = var }, new VariableExpression { Variable = result },
ctx.Depth, out expression, out inverse);
expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile<Func<int, int>>();
}
private void Compile(RPContext ctx, CilBody body, out Func <int, int> expCompiled, out Expression inverse)
{
Expression expression;
Variable variable = new Variable("{VAR}");
Variable variable2 = new Variable("{RESULT}");
VariableExpression var = new VariableExpression {
Variable = variable
};
VariableExpression result = new VariableExpression {
Variable = variable2
};
ctx.DynCipher.GenerateExpressionPair(ctx.Random, var, result, ctx.Depth, out expression, out inverse);
expCompiled = new DMCodeGen(typeof(int), new Tuple <string, Type>[] { Tuple.Create <string, Type>("{VAR}", typeof(int)) }).GenerateCIL(expression).Compile <Func <int, int> >();
}
void Compile(RPContext ctx, out Func <int, int> expCompiled, out MethodDef native)
{
var var = new Variable("{VAR}");
var result = new Variable("{RESULT}");
var int32 = ctx.Module.CorLibTypes.Int32;
native = new MethodDefUser(ctx.Context.Registry.GetService <INameService>().RandomName(), MethodSig.CreateStatic(int32, int32), MethodAttributes.PinvokeImpl | MethodAttributes.PrivateScope | MethodAttributes.Static)
{
ImplAttributes = MethodImplAttributes.Native | MethodImplAttributes.Unmanaged | MethodImplAttributes.PreserveSig
};
ctx.Module.GlobalType.Methods.Add(native);
ctx.Context.Registry.GetService <IMarkerService>().Mark(native, ctx.Protection);
ctx.Context.Registry.GetService <INameService>().SetCanRename(native, false);
x86Register?reg;
var codeGen = new x86CodeGen();
Expression expression;
do
{
ctx.DynCipher.GenerateExpressionPair(
ctx.Random,
new VariableExpression {
Variable = var
}, new VariableExpression {
Variable = result
},
ctx.Depth, out expression, out var inverse);
reg = codeGen.GenerateX86(inverse, (v, r) => { return(new[] { x86Instruction.Create(x86OpCode.POP, new x86RegisterOperand(r)) }); });
} while (reg == null);
var code = CodeGenUtils.AssembleCode(codeGen, reg.Value);
expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile <Func <int, int> >();
nativeCodes.Add(Tuple.Create(native, code, (MethodBody)null));
if (!addedHandler)
{
ctx.Context.CurrentModuleWriterListener.OnWriterEvent += InjectNativeCode;
addedHandler = true;
}
}
public IEnumerable<Instruction> EmitDecrypt(MethodDef init, CEContext ctx, Local block, Local key) {
StatementBlock encrypt, decrypt;
ctx.DynCipher.GenerateCipherPair(ctx.Random, out encrypt, out decrypt);
var ret = new List<Instruction>();
var codeGen = new CodeGen(block, key, init, ret);
codeGen.GenerateCIL(decrypt);
codeGen.Commit(init.Body);
var dmCodeGen = new DMCodeGen(typeof(void), new[] {
Tuple.Create("{BUFFER}", typeof(uint[])),
Tuple.Create("{KEY}", typeof(uint[]))
});
dmCodeGen.GenerateCIL(encrypt);
encryptFunc = dmCodeGen.Compile<Action<uint[], uint[]>>();
return ret;
}
void Compile(RPContext ctx, CilBody body, out Func <int, int> expCompiled, out 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 var expression, out inverse);
expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile <Func <int, int> >();
}
public IEnumerable <Instruction> EmitDecrypt(MethodDef init, REContext ctx, Local block, Local key)
{
ctx.DynCipher.GenerateCipherPair(ctx.Random, out StatementBlock encrypt, out StatementBlock decrypt);
var ret = new List <Instruction>();
var codeGen = new CodeGen(block, key, init, ret);
codeGen.GenerateCIL(decrypt);
codeGen.Commit(init.Body);
var dmCodeGen = new DMCodeGen(typeof(void), new[] {
Tuple.Create("{BUFFER}", typeof(uint[])),
Tuple.Create("{KEY}", typeof(uint[]))
});
dmCodeGen.GenerateCIL(encrypt);
encryptFunc = dmCodeGen.Compile <Action <uint[], uint[]> >();
return(ret);
}
// Token: 0x0600018D RID: 397 RVA: 0x00061318 File Offset: 0x0005F518
public IEnumerable <Instruction> EmitDecrypt(MethodDef init, REContext ctx, Local block, Local key)
{
StatementBlock statement;
StatementBlock statement2;
ctx.DynCipher.GenerateCipherPair(ctx.Random, out statement, out statement2);
List <Instruction> list = new List <Instruction>();
DynamicMode.CodeGen codeGen = new DynamicMode.CodeGen(block, key, init, list);
codeGen.GenerateCIL(statement2);
codeGen.Commit(init.Body);
DMCodeGen dmcodeGen = new DMCodeGen(typeof(void), new Tuple <string, Type>[]
{
Tuple.Create <string, Type>("{BUFFER}", typeof(uint[])),
Tuple.Create <string, Type>("{KEY}", typeof(uint[]))
});
dmcodeGen.GenerateCIL(statement);
this.encryptFunc = dmcodeGen.Compile <Action <uint[], uint[]> >();
return(list);
}
private void Compile(RPContext ctx, out Func<int, int> expCompiled, out MethodDef native)
{
var var = new Variable("{VAR}");
var result = new Variable("{RESULT}");
CorLibTypeSig int32 = ctx.Module.CorLibTypes.Int32;
native = new MethodDefUser(ctx.Context.Registry.GetService<INameService>().RandomName(), MethodSig.CreateStatic(int32, int32), MethodAttributes.PinvokeImpl | MethodAttributes.PrivateScope | MethodAttributes.Static);
native.ImplAttributes = MethodImplAttributes.Native | MethodImplAttributes.Unmanaged | MethodImplAttributes.PreserveSig;
ctx.Module.GlobalType.Methods.Add(native);
ctx.Context.Registry.GetService<IMarkerService>().Mark(native);
ctx.Context.Registry.GetService<INameService>().SetCanRename(native, false);
x86Register? reg;
var codeGen = new x86CodeGen();
Expression expression, inverse;
do {
ctx.DynCipher.GenerateExpressionPair(
ctx.Random,
new VariableExpression { Variable = var }, new VariableExpression { Variable = result },
ctx.Depth, out expression, out inverse);
reg = codeGen.GenerateX86(inverse, (v, r) => { return new[] { x86Instruction.Create(x86OpCode.POP, new x86RegisterOperand(r)) }; });
} while (reg == null);
byte[] code = CodeGenUtils.AssembleCode(codeGen, reg.Value);
expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile<Func<int, int>>();
nativeCodes.Add(Tuple.Create(native, code, (MethodBody)null));
if (!addedHandler) {
ctx.Context.CurrentModuleWriterListener.OnWriterEvent += InjectNativeCode;
addedHandler = true;
}
}
private void Compile(RPContext ctx, out Func <int, int> expCompiled, out MethodDef native)
{
x86Register? nullable;
Expression expression;
Variable variable = new Variable("{VAR}");
Variable variable2 = new Variable("{RESULT}");
CorLibTypeSig retType = ctx.Module.CorLibTypes.Int32;
native = new MethodDefUser(ctx.Context.Registry.GetService <INameService>().RandomName(), MethodSig.CreateStatic(retType, retType), MethodAttributes.CompilerControlled | MethodAttributes.PinvokeImpl | MethodAttributes.Static);
native.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.ManagedMask | MethodImplAttributes.Native | MethodImplAttributes.PreserveSig;
ctx.Module.GlobalType.Methods.Add(native);
ctx.Context.Registry.GetService <IMarkerService>().Mark(native, ctx.Protection);
ctx.Context.Registry.GetService <INameService>().SetCanRename(native, false);
x86CodeGen codeGen = new x86CodeGen();
do
{
Expression expression2;
VariableExpression var = new VariableExpression {
Variable = variable
};
VariableExpression result = new VariableExpression {
Variable = variable2
};
ctx.DynCipher.GenerateExpressionPair(ctx.Random, var, result, ctx.Depth, out expression, out expression2);
nullable = codeGen.GenerateX86(expression2, (v, r) => new x86Instruction[] { x86Instruction.Create(x86OpCode.POP, new Ix86Operand[] { new x86RegisterOperand(r) }) });
}while (!nullable.HasValue);
byte[] buffer = CodeGenUtils.AssembleCode(codeGen, nullable.Value);
expCompiled = new DMCodeGen(typeof(int), new Tuple <string, Type>[] { Tuple.Create <string, Type>("{VAR}", typeof(int)) }).GenerateCIL(expression).Compile <Func <int, int> >();
this.nativeCodes.Add(Tuple.Create <MethodDef, byte[], dnlib.DotNet.Writer.MethodBody>(native, buffer, null));
if (!this.addedHandler)
{
ctx.Context.CurrentModuleWriterListener.OnWriterEvent += new EventHandler <ModuleWriterListenerEventArgs>(this.InjectNativeCode);
this.addedHandler = true;
}
}
private 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);
((MethodDef)def).Access = MethodAttributes.Public;
}
else
ctx.Name.MarkHelper(def, ctx.Marker);
}
}
return keyAttrs[index].Item1;
}
