private void Obfuscate(BuildMethod method) { if (!method.ObfuscateStrings) { return; } if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); if (!HasLoadStringInstruction(methodBody)) { return; } var ilBody = ILBody.Load(methodBody); Obfuscate(ilBody); ilBody.CalculateMaxStackSize(method); methodBody = ilBody.Build(); methodBody.Build(method); }
private void GenerateGlobalCCtor(BuildMethod proxyMethod) { var ownerType = _module.Types.GetOrCreateGlobal(); var method = ownerType.Methods.GetOrCreateStaticConstructor(); MethodBody methodBody; if (MethodBody.IsValid(method)) { methodBody = MethodBody.Load(method); } else { methodBody = new MethodBody(); methodBody.Instructions.Add(new Instruction(OpCodes.Ret)); } if (methodBody.MaxStackSize < 2) { methodBody.MaxStackSize = 2; } methodBody.Instructions.Insert(0, new Instruction(OpCodes.Call, proxyMethod.ToReference(proxyMethod.Module))); methodBody.ShiftRightExceptionHandlerOffsets(1); methodBody.Build(method); }
private bool IsMainTypeInitMethod(BuildMethod method) { return (method.IsStaticConstructor() || method.Name == "InitializeControlFlow" || method.Name == "InitializeMethodPointers"); }
private void ObfuscateControlFlowInitMethod(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); var ilBody = ILBody.Load(methodBody); // Obfuscate var obfuscator = new ControlFlowObfuscator(ilBody, method); obfuscator.DoNotUseFieldNumber = true; obfuscator.Obfuscate(); // Calculate max stack size ilBody.CalculateMaxStackSize(method); // Save methodBody = ilBody.Build(); methodBody.Build(method); }
private void Build(BuildMethod method) { var cryptoMethod = method.CreateILCrypto(); var type = method.GetOwnerType(); var invokeTypeInfo = GetInvokeType(type.GenericParameters.Count); var invokeType = invokeTypeInfo.Instance; cryptoMethod.MethodID = invokeType.MethodCount++; // Delegate type var delegateGenericArguments = new List <TypeSignature>(); var delegateType = _delegateTypeBuilder.Build(method, delegateGenericArguments); if (delegateGenericArguments.Count > 0) { cryptoMethod.DelegateGenericArguments = delegateGenericArguments.ToArray(); } // Invoke method var invokeGenericArguments = new List <TypeSignature>(); var invokeMethod = BuildInvokeMethod(method, invokeTypeInfo, invokeGenericArguments); invokeMethod.DelegateType = delegateType; cryptoMethod.InvokeMethod = invokeMethod; if (invokeGenericArguments.Count > 0) { cryptoMethod.InvokeGenericArguments = invokeGenericArguments.ToArray(); } }
public static void Obfuscate(BuildMethod method, bool ignoreEncryptIL) { if (!method.ObfuscateControlFlow) { return; } if (ignoreEncryptIL && method.EncryptIL) { return; } if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); var ilBody = ILBody.Load(methodBody); // Obfuscate var obfuscator = new ControlFlowObfuscator(ilBody, method); obfuscator.Obfuscate(); // Save methodBody = ilBody.Build(); methodBody.Build(method); }
private bool Build(ref MethodReference methodRef, BuildMethod method) { bool changed = false; // Name string name; if (method.NameChanged) { name = method.NewName; changed = true; } else { name = method.Name; } // Owner var owner = methodRef.Owner; changed |= Build(ref owner); // Call site var callSite = methodRef.CallSite; changed |= Build(ref callSite); if (!changed) return false; methodRef = new MethodReference(name, owner, callSite); return true; }
private void UnstripAndEnqueue(BuildMethod method) { if (method.Strip) { method.Strip = false; Enqueue(method); } }
private void Enqueue(BuildMethod method) { if (!method.StripProcessed) { method.StripProcessed = true; _queue.Enqueue(method); } }
private InvokeMethodInfo BuildInvokeMethod(BuildMethod method, List <TypeSignature> genericArguments) { var invokeMethodInfo = new InvokeMethodInfo(); int argumentCount = method.Parameters.Count + 1; if (method.HasThis) { argumentCount++; } var arguments = new TypeSignature[argumentCount]; var parameterFlags = new int[argumentCount]; // Arguments { int index = 0; if (method.HasThis) { arguments[index++] = new GenericParameterType(true, 0); genericArguments.Add(TypeReference.GetPrimitiveType(PrimitiveTypeCode.Object, _module.Assembly)); } var parameters = method.Parameters; for (int i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; arguments[index] = BuildType(parameter.Type, genericArguments); parameterFlags[index] = GetParameterFlags(parameter); index++; } // index : [mscorlib]System.Int32 arguments[index++] = TypeReference.GetPrimitiveType(PrimitiveTypeCode.Int32, _module.Assembly); } var returnType = BuildType(method.ReturnType.Type, genericArguments); invokeMethodInfo.CallSite = new CallSite( false, false, MethodCallingConvention.Default, returnType, arguments, -1, genericArguments.Count); invokeMethodInfo.ParameterFlags = parameterFlags; invokeMethodInfo.GenericParameterCount = genericArguments.Count; return(invokeMethodInfo); }
private DelegateTypeInfo BuildInfo(BuildMethod method, List <TypeSignature> genericArguments) { var typeInfo = new DelegateTypeInfo(); int argumentCount = method.Parameters.Count; if (method.HasThis) { argumentCount++; } var arguments = new TypeSignature[argumentCount]; var parameterFlags = new int[argumentCount]; if (argumentCount > 0) { int index = 0; if (method.HasThis) { arguments[index++] = new GenericParameterType(false, 0); genericArguments.Add(TypeReference.GetPrimitiveType(PrimitiveTypeCode.Object, _module.Assembly)); } var parameters = method.Parameters; for (int i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; arguments[index] = BuildType(parameter.Type, genericArguments); parameterFlags[index] = GetParameterFlags(parameter); index++; } } var returnType = BuildType(method.ReturnType.Type, genericArguments); typeInfo.InvokeCallSite = new CallSite( true, false, MethodCallingConvention.Default, returnType, arguments, -1, 0); typeInfo.InvokeParameterFlags = parameterFlags; typeInfo.GenericParameterCount = genericArguments.Count; return(typeInfo); }
private void Analyze(BuildMethod method) { var attr = CA.BindableAttribute.FindFirst(method.CustomAttributes); if (attr != null && attr.Bindable) { if (!_renameBindableMembers) { method.Rename = false; } method.Strip = false; } }
private void Analyze(BuildMethod method, bool serializable) { LoadSerializableAttributes(ref serializable, method.CustomAttributes); if (serializable) { if (!_renameSerializableMembers) { method.Rename = false; } method.Strip = false; } }
private void Analyze(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var body = MethodBody.Load(method); var instructions = body.Instructions; for (int i = 0; i < instructions.Count; i++) { var instruction = instructions[i]; var opCode = instruction.OpCode; if (opCode == OpCodes.Newobj) { var calledMethodSig = instruction.Value as MethodReference; if (calledMethodSig != null) { if (IsResourceManagerCtorWithType(calledMethodSig)) { var typeSig = FindPrevLdtoken(instructions, i - 1) as TypeSignature; if (typeSig != null) { Unmark(typeSig); } } else if (IsComponentResourceManagerCtorWithType(calledMethodSig)) { var typeSig = FindPrevLdtoken(instructions, i - 1) as TypeSignature; if (typeSig != null) { Unmark(typeSig); } } else if (IsBitmapCtorWithType(calledMethodSig)) { var typeSig = FindPrevLdtoken(instructions, i - 1) as TypeSignature; if (typeSig != null) { Unmark(typeSig); } } } } } }
private static void Unmark(BuildMethod method) { if (method.Strip) { method.DevirtualizeMethod = false; method.StripObfuscationAttribute = false; if (!method.StripEncrypted) { method.Rename = false; method.NameChanged = false; method.EncryptIL = false; method.ObfuscateControlFlow = false; method.ObfuscateStrings = false; } } }
public static void Build(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); if (methodBody == null) { return; } var builder = new Builder(method); bool changed = false; var instructions = methodBody.Instructions; for (int i = 0; i < instructions.Count; i++) { var instruction = instructions[i]; if (instruction.OpCode != OpCodes.Call && instruction.OpCode != OpCodes.Callvirt) { continue; } var calledMethodSig = instruction.Value as MethodSignature; if (calledMethodSig == null) { continue; } if (builder.Build(ref calledMethodSig)) { instructions[i] = new Instruction(instruction.OpCode, calledMethodSig); changed = true; } } if (changed) { methodBody.Build(method); } }
private void Map(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); var ilBody = ILBody.Load(methodBody); if (Map(ilBody)) { ilBody.CalculateMaxStackSize(method); methodBody = ilBody.Build(); methodBody.Build(method); } }
private void UnstripAndEnqueueEncrypted(BuildMethod method) { if (!method.Strip || method.StripEncrypted) { return; } if (method.EncryptIL && !method.IsVirtual) { method.StripEncrypted = true; } else { method.Strip = false; } Enqueue(method); }
private bool CanStrip(BuildMethod method) { if (method.IsVirtual) { return(false); } if (method.IsConstructor()) { return(false); } if (method.CodeType != MethodCodeTypeFlags.CIL) { return(false); } return(true); }
public ControlFlowObfuscator(ILBody body, BuildMethod method) { if (body == null) { throw new ArgumentNullException("body"); } if (method == null) { throw new ArgumentNullException("method"); } _body = body; _method = method; var module = (BuildModule)method.Module; _mainType = module.MainType; _random = module.RandomGenerator; }
public static void Change(BuildMethod method) { if (method.NameChanged) { method.Name = method.NewName; } if (method.Rename || method.IsConstructor()) { foreach (var parameter in method.Parameters) { parameter.Name = null; } foreach (var genericParameter in method.GenericParameters) { genericParameter.Name = null; } } }
private void Process(BuildMethod method) { UnstripAndEnqueue((BuildType)method.GetOwnerType()); // Process references var module = method.Module; Process(method.ReturnType, module); Process(method.Parameters, module); Process(method.GenericParameters, module); Process(method.Overrides, module); Process(method.CustomAttributes, module); Process(method.SecurityAttributes, module); if (MethodBody.IsValid(method)) { var body = MethodBody.Load(method); Process(body, module); } }
public DelegateType Build(BuildMethod method, List <TypeSignature> genericArguments) { var typeInfo = BuildInfo(method, genericArguments); int index; if (_types.TryAdd(typeInfo, out index)) { var delegateType = _module.DelegateTypes.Add(); delegateType.GenericParameterCount = typeInfo.GenericParameterCount; delegateType.InvokeParameterFlags = typeInfo.InvokeParameterFlags; delegateType.InvokeCallSite = typeInfo.InvokeCallSite; typeInfo.Instance = delegateType; return(delegateType); } else { return(_types[index].Instance); } }
private static void DevirtualizeMethod(BuildMethod method) { if (!method.DevirtualizeMethod) { return; } if (!method.IsVirtual) { return; } var ownerType = method.GetOwnerType(); if (ownerType.IsInterface) { return; } method.IsVirtual = false; method.IsNewSlot = false; }
private ILCryptoInvokeMethod BuildInvokeMethod(BuildMethod method, InvokeTypeInfo invokeTypeInfo, List <TypeSignature> genericArguments) { var invokeMethodInfo = BuildInvokeMethod(method, genericArguments); int index; if (invokeTypeInfo.Methods.TryAdd(invokeMethodInfo, out index)) { var invokeMethod = invokeTypeInfo.Instance.InvokeMethods.Add(); invokeMethod.GenericParameterCount = invokeMethodInfo.GenericParameterCount; invokeMethod.ParameterFlags = invokeMethodInfo.ParameterFlags; invokeMethod.CallSite = invokeMethodInfo.CallSite; invokeMethod.OwnerType = invokeTypeInfo.Instance; invokeMethodInfo.Instance = invokeMethod; return(invokeMethod); } else { return(invokeTypeInfo.Methods[index].Instance); } }
private void ObfuscateControlFlow(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); var ilBody = ILBody.Load(methodBody); // Call proxy if (_callProxyBuilder != null) { _callProxyBuilder.Build(ilBody); } // Function pointers if (_functionPointerBuilder != null) { _functionPointerBuilder.Build(ilBody); } // Obfuscate var obfuscator = new ControlFlowObfuscator(ilBody, method); obfuscator.Obfuscate(); // Calculate max stack size ilBody.CalculateMaxStackSize(method); // Save methodBody = ilBody.Build(); methodBody.Build(method); }
private static void DevirtualizeCalls(BuildMethod method) { if (!MethodBody.IsValid(method)) { return; } var methodBody = MethodBody.Load(method); if (methodBody == null) { return; } bool changed = false; var instructions = methodBody.Instructions; for (int i = 0; i < instructions.Count; i++) { var instruction = instructions[i]; var opCode = instruction.OpCode; if (opCode.Type == OpCodeType.Prefix) { i++; continue; } if (opCode != OpCodes.Callvirt) { continue; } var calledMethodSig = instruction.Value as MethodSignature; if (calledMethodSig == null) { continue; } var calledMethod = calledMethodSig.Resolve(method.Module, true); if (calledMethod == null) { continue; } var calledDeclaringMethod = calledMethod.DeclaringMethod as BuildMethod; if (calledDeclaringMethod == null) { continue; } if (!calledDeclaringMethod.DevirtualizeMethod) { continue; } instructions[i] = new Instruction(OpCodes.Call, instruction.Value); changed = true; } if (changed) { methodBody.Build(method); } }
public static void Devirtualize(BuildMethod method) { DevirtualizeMethod(method); DevirtualizeCalls(method); }
public Builder(BuildMethod owner) { _owner = owner; _module = owner.Module; _assemblyManager = owner.AssemblyManager; }