static Statement ReplaceVar(Statement st, Variable buff) { if (st is AssignmentStatement) { ((AssignmentStatement)st).Value = ReplaceVar(((AssignmentStatement)st).Value, buff); ((AssignmentStatement)st).Target = ReplaceVar(((AssignmentStatement)st).Target, buff); } return st; }
public CipherGenContext(RandomGenerator random, int dataVarCount) { this.random = random; Block = new StatementBlock(); // new LoopStatement() { Begin = 0, Limit = 4 }; dataVars = new Variable[dataVarCount]; for (int i = 0; i < dataVarCount; i++) dataVars[i] = new Variable("v" + i) { Tag = i }; }
protected override Local Var(Variable var) { if (var.Name == "{BUFFER}") return block; if (var.Name == "{KEY}") return key; return base.Var(var); }
protected override void LoadVar(Variable var) { if (var.Name == "{RESULT}") { foreach (Instruction instr in arg) Emit(instr); } else base.LoadVar(var); }
protected virtual Local Var(Variable var) { Local ret; if (!localMap.TryGetValue(var.Name, out ret)) { ret = new Local(Method.Module.CorLibTypes.UInt32); ret.Name = var.Name; localMap[var.Name] = ret; } return ret; }
public IDisposable AcquireTempVar(out VariableExpression exp) { Variable var; if (tempVars.Count == 0) var = new Variable("t" + tempVarCounter++); else { var = tempVars[random.NextInt32(tempVars.Count)]; tempVars.Remove(var); } exp = new VariableExpression { Variable = var }; return new TempVarHolder(this, var); }
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>>(); }
void Compile(CilBody body) { 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); expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) }) .GenerateCIL(expression) .Compile<Func<int, int>>(); invCompiled = new List<Instruction>(); new CodeGen(stateVar, ctx, invCompiled).GenerateCIL(inverse); body.MaxStack += (ushort)ctx.Depth; }
static Expression ReplaceVar(Expression exp, Variable buff) { if (exp is VariableExpression) { if (((VariableExpression)exp).Variable.Name[0] != 'v') return exp; return new ArrayIndexExpression { Array = new VariableExpression { Variable = buff }, Index = (int)(exp as VariableExpression).Variable.Tag }; } if (exp is ArrayIndexExpression) { ((ArrayIndexExpression)exp).Array = ReplaceVar(((ArrayIndexExpression)exp).Array, buff); } else if (exp is BinOpExpression) { ((BinOpExpression)exp).Left = ReplaceVar(((BinOpExpression)exp).Left, buff); ((BinOpExpression)exp).Right = ReplaceVar(((BinOpExpression)exp).Right, buff); } else if (exp is UnaryOpExpression) { ((UnaryOpExpression)exp).Value = ReplaceVar(((UnaryOpExpression)exp).Value, buff); } return exp; }
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; } }
public void Compile(CFContext ctx) { var var = new Variable("{VAR}"); var result = new Variable("{RESULT}"); CorLibTypeSig int32 = ctx.Method.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; // Attempt to improve performance --- failed with StackOverflowException... :/ //var suppressAttr = ctx.Method.Module.CorLibTypes.GetTypeRef("System.Security", "SuppressUnmanagedCodeSecurityAttribute").ResolveThrow(); //native.CustomAttributes.Add(new CustomAttribute((MemberRef)ctx.Method.Module.Import(suppressAttr.FindDefaultConstructor()))); //native.HasSecurity = true; ctx.Method.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(); 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); code = CodeGenUtils.AssembleCode(codeGen, reg.Value); expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) }) .GenerateCIL(expression) .Compile<Func<int, int>>(); ctx.Context.CurrentModuleWriterListener.OnWriterEvent += InjectNativeCode; }
protected override Local Var(Variable var) { if (var.Name == "{RESULT}") return state; return base.Var(var); }
protected virtual void StoreVar(Variable var) { Emit(Instruction.Create(OpCodes.Stloc, Var(var))); }
protected virtual void LoadVar(Variable var) { Emit(Instruction.Create(OpCodes.Ldloc, Var(var))); }
public static void Run(StatementBlock block) { var mainBuff = new Variable("{BUFFER}"); for (int i = 0; i < block.Statements.Count; i++) block.Statements[i] = ReplaceVar(block.Statements[i], mainBuff); }
public TempVarHolder(CipherGenContext p, Variable v) { parent = p; tempVar = v; }
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; }