private static void CreateAssembly(string assembly, Bitness bitness, Action <ModuleDefMD> modifyAction = null) { var creationOptions = new ModuleCreationOptions { Context = ModuleDef.CreateModuleContext(), TryToLoadPdbFromDisk = true }; using var module = ModuleDefMD.Load(assembly, creationOptions); ChangeBitness(module, bitness); modifyAction?.Invoke(module); DisableEditAndContinueForModule(module); var path = Path.GetDirectoryName(module.Location); var filename = Path.GetFileNameWithoutExtension(module.Location); var extension = Path.GetExtension(module.Location); var saveFilename = $"{filename}.{bitness}{extension}"; module.Name = saveFilename; var moduleWriterOptions = new ModuleWriterOptions(module) { AddCheckSum = true, WritePdb = true }; var moduleWriter = new ModuleWriter(module, moduleWriterOptions); ReplaceMSCOREEReferenceWithIJWHostForNetCoreApp(module, moduleWriter); moduleWriter.Write(Path.Combine(path, saveFilename)); }
public static AssemblyPublicInterface Load(byte[] assemblyBytes) { var modCtx = ModuleDef.CreateModuleContext(); var module = ModuleDefMD.Load(assemblyBytes, modCtx); return(BuildAssemblyPublicInterface(module)); }
public static void main_poly(string username, int tn) { ModuleContext mod_ctx = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(@"ldr_base.exe", mod_ctx); if (module == null) { Console.WriteLine("module is null (HOW??)"); return; } Console.WriteLine("tn[{1}] - got module for username {0}", username, tn); /* * big credits to: https://blog.syscall.party/post/writing-a-simple-net-deobfuscator/ * idea and some functions from ^ */ polymorphic.set_username(username); foreach (var type in module.GetTypes()) { //this gives us classes, functions, functions body, etc polymorphic.modify_strings(type); } polymorphic.finish_write(module, username, tn); }
/// <summary> /// Strips the IL from the given assembly, leaving only a reference assembly with no executable code. /// </summary> private static void StripAssembly(string filePath) { Console.WriteLine($"Stripping Assembly: {Path.GetFileName(filePath)}"); ModuleContext context = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(filePath, context); foreach (TypeDef type in module.Types) { StripType(type); } // HACK: What if we need to reference embedded resources like localized strings? Can we empty just the resource CONTENTS? module.Resources?.Clear(); string outPath = Path.Combine(Path.GetDirectoryName(filePath), "Stripped", Path.GetFileName(filePath)); Directory.CreateDirectory(Path.GetDirectoryName(outPath)); if (module.IsILOnly) { module.Write(outPath, new ModuleWriterOptions(module) { ShareMethodBodies = true }); } else { // Mixed Mode Assembly module.NativeWrite(outPath, new NativeModuleWriterOptions(module, optimizeImageSize: true) { ShareMethodBodies = true }); } }
public void Compile(string inputFilePath, string outputFilePath) { ModuleContext modCtx = ModuleDef.CreateModuleContext(); var corlibFilePath = _configuration.CorelibPath; if (string.IsNullOrEmpty(corlibFilePath)) { var inputDirectoryName = Path.GetDirectoryName(inputFilePath); if (inputDirectoryName != null) { corlibFilePath = Path.Combine(inputDirectoryName, "System.Private.CoreLib.dll"); } } ModuleDefMD corlibModule = ModuleDefMD.Load(corlibFilePath, modCtx); var corlibAssemblyRef = corlibModule.Assembly.ToAssemblyRef(); var options = new ModuleCreationOptions(modCtx) { CorLibAssemblyRef = corlibAssemblyRef }; ModuleDefMD module = ModuleDefMD.Load(inputFilePath, options); var typesToCompile = new List <TypeDef>(); typesToCompile.AddRange(corlibModule.Types); typesToCompile.AddRange(module.Types); var rootNode = _typeDependencyAnalyser.AnalyseDependencies(typesToCompile, module.EntryPoint); CompileNode(rootNode); _z80Writer.OutputCode(rootNode, inputFilePath, outputFilePath); }
static void Main(string[] args) { while (true) { Console.Clear(); string modulePath = ""; int proxyDepth = 0; try { modulePath = args[0]; } catch (IndexOutOfRangeException) { Console.WriteLine("Error : no module selected... press ENTER to exit."); Console.ReadLine(); Environment.Exit(0); } Console.Write("Proxy depth : "); int.TryParse(Console.ReadLine(), out proxyDepth); if (proxyDepth < 1) { Console.WriteLine("Invalid proxy depth (should be greater than 1)"); Thread.Sleep(700); continue; } Console.Clear(); ModuleContext modCtx = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(modulePath, modCtx); var myProxyRemover = new ProxyRemover(module, modulePath); int removedProxies = myProxyRemover.RemoveProxiesFromTypes(module.Types, proxyDepth); if (removedProxies > 0) { Console.WriteLine(); } Console.WriteLine(removedProxies + " proxies removed"); Console.WriteLine(); if (removedProxies > 0) { Console.WriteLine("Saving module..."); myProxyRemover.SaveModule(); } Console.WriteLine("Done."); Console.ReadLine(); break; } }
static TypeExtensions() { var module = typeof(TypeExtensions).Module; var context = ModuleDef.CreateModuleContext(); var moduleDef = ModuleDefMD.Load(module, context); _types = moduleDef.Types.ToList(); var nestedTypes = _types.SelectMany(t => t.NestedTypes ?? Enumerable.Empty <TypeDef>()).ToList(); _types.AddRange(nestedTypes); }
public void Run() { ModuleContext context = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(opts.InputAssemblyPath, context); foreach (IDeobfuscationPass pass in passes) { pass.Run(module, opts); } module.Write(opts.OutputAssemblyPath); }
public static MonoDecompiler FromFile(string path) { if (!File.Exists(path)) { return(null); } ModuleContext modCtx = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(path, modCtx); return(new MonoDecompiler(module)); }
private void LoadModuleCatalog() { if (!ModulesDirectory.Exists) { throw new InvalidOperationException($"Directory {ModulesDirectory} could not be found."); } var loadedAssemblies = GetLoadedAssemblies(); Log.Debug($"Loaded assembly list:\n\t{loadedAssemblies.Select(x => new {x.FullName, x.Location}).DumpToTable()}"); var existingModules = moduleCatalog.Modules.ToArray(); Log.Debug( $"Default Modules list:\n\t{existingModules.Select(x => new {x.ModuleName, x.ModuleType, x.Ref, x.State, x.InitializationMode, x.DependsOn}).DumpToTable()}"); var potentialModules = ( from dllFile in ModulesDirectory.GetFiles("*.dll") let loadedModules = loadedAssemblies.Where(x => !string.IsNullOrEmpty(x.Location)) .Select(x => new FileInfo(x.Location)) .Where(x => x.Exists) .ToArray() where !loadedModules.Contains(dllFile) let moduleContext = ModuleDef.CreateModuleContext() let dllFileData = File.ReadAllBytes(dllFile.FullName) let module = LoadModuleSafe(dllFileData, moduleContext, dllFile.FullName) where module != null select new {module, dllFile}).ToArray(); var discoveredModules = ( from item in potentialModules from prismBootstrapper in GetPrismBootstrapperTypes(item.module) select new {item.dllFile, item.module, prismBootstrapper}).ToArray(); Log.Debug( $"Discovered {discoveredModules.Length} modules:\n\t{discoveredModules.Select(x => new {x.dllFile.FullName, x.module.Metadata.VersionString, x.prismBootstrapper.AssemblyQualifiedName}).DumpToTable()}"); foreach (var module in discoveredModules) { Log.Debug($"Loading modules from file {module.dllFile}"); if (AppArguments.Instance.IsLazyMode) { var moduleInfo = PrepareLocalModuleInfo(module.prismBootstrapper, module.dllFile); Log.Debug($"LazyMode is enabled, adding ModuleInfo: {moduleInfo}"); moduleCatalog.AddModule(moduleInfo); } else { var assemblyBytes = File.ReadAllBytes(module.dllFile.FullName); LoadModulesFromBytes(assemblyBytes); } } }
static void ParseModule(string moduleFile) { ModuleContext modCtx = ModuleDef.CreateModuleContext(); currentModule = ModuleDefMD.Load(moduleFile, modCtx); string moduleOutput = OUTPUT_DIR + "\\" + currentModule.Name; if (!Directory.Exists(moduleOutput)) { Directory.CreateDirectory(moduleOutput); } ParseClasses(); }
public static void LoadModule(string filename) { try { FileName = filename; byte[] data = File.ReadAllBytes(filename); ModuleContext modCtx = ModuleDef.CreateModuleContext(); module = ModuleDefMD.Load(data, modCtx); Write("Module Loaded : " + module.Name, TypeMessage.Info); } catch { Write("Error for Loade Module", TypeMessage.Error); } }
// Token: 0x06000067 RID: 103 RVA: 0x00006AB0 File Offset: 0x00004CB0 public static void LoadModule(string filename) { try { context.FileName = filename; byte[] data = File.ReadAllBytes(filename); ModuleContext context = ModuleDef.CreateModuleContext(); context.module = ModuleDefMD.Load(data, context); foreach (AssemblyRef assemblyRef in context.module.GetAssemblyRefs()) { } } catch { } }
public static void Main(string[] args) { var ctx = ModuleDef.CreateModuleContext(); //var module = ModuleDefMD.Load("/Users/mustafa/Work/digitoygames/digiplay-net/OkeyExtra/iOS/bin/iPhone/Debug/OkeyExtra.exe", ctx); //var module = ModuleDefMD.Load("/Users/mustafa/Projects/csharp/bin/Debug/csharp.exe", ctx); var module = ModuleDefMD.Load("/Users/mustafa/Work/digitoygames/digiplay-net/GinRummyExtra/Android/bin/Debug/GinRummyExtra.dll", ctx); CorLibTypes corLibTypes = new CorLibTypes(module); CPP(module); return; var buffer = new StringBuilder(); foreach (var type in module.GetTypes()) { //if (!type.FullName.StartsWith("Test")) continue; buffer.Append("Type=" + type.FullName); if (type.GenericParameters != null) { foreach (var g in type.GenericParameters) { buffer.Append(" Gen=" + g.FullName); } } buffer.Append("\n"); foreach (var f in type.Fields) { buffer.Append(" field:" + f.Name + " " + f.FieldType + "\n"); } Test(module, type, corLibTypes, buffer); if (type.NestedTypes != null) { foreach (var nt in type.NestedTypes) { buffer.Append("Type=" + nt.FullName + "\n"); foreach (var f in nt.Fields) { buffer.Append(" field:" + f.Name + " " + f.FieldType + "\n"); } Test(module, nt, corLibTypes, buffer); } } } System.IO.File.WriteAllText("il.txt", buffer.ToString()); }
/// <summary> /// Hotloads an assembly. Redirects to <see cref="Assembly.Load(byte[])"/> if <see cref="Enabled"/> is set to false. /// </summary> /// <param name="assemblyData">The assembly to hotload.</param> /// <returns>The loaded assembly.</returns> public static Assembly LoadAssembly(byte[] assemblyData) { if (!Enabled) { return(Assembly.Load(assemblyData)); } using var input = new MemoryStream(assemblyData, writable: false); using var output = new MemoryStream(); var modCtx = ModuleDef.CreateModuleContext(); var module = ModuleDefMD.Load(input, modCtx); var isMono = Type.GetType("Mono.Runtime") != null; var isStrongNamed = module.Assembly.PublicKey != null; if (!isMono && isStrongNamed) { // Don't hotload strong-named assemblies unless mono // Will cause FileLoadException's if not mono return(Assembly.Load(assemblyData)); } var realFullname = module.Assembly.FullName; if (s_Assemblies.ContainsKey(realFullname)) { s_Assemblies.Remove(realFullname); } var guid = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6); var name = $"{module.Assembly.Name}-{guid}"; module.Assembly.Name = name; module.Assembly.PublicKey = null; module.Assembly.HasPublicKey = false; module.Write(output); output.Seek(offset: 0, SeekOrigin.Begin); var newAssemblyData = output.ToArray(); var assembly = Assembly.Load(newAssemblyData); s_Assemblies.Add(realFullname, assembly); return(assembly); }
static void ParseModule(string moduleFile) { Console.WriteLine("Generating SDK for {0}...", Path.GetFileName(moduleFile)); ModuleContext modCtx = ModuleDef.CreateModuleContext(); currentModule = ModuleDefMD.Load(moduleFile, modCtx); string moduleOutput = OUTPUT_DIR + "\\" + currentModule.Name; if (!Directory.Exists(moduleOutput)) { Directory.CreateDirectory(moduleOutput); } ParseClasses(); }
private static void Main(string[] args) { // Parse commands Parser.Default.ParseArguments <Options>(args).WithParsed(_opts => Arguments = _opts); if (Arguments == null) { Console.ReadKey(); return; } if (!Directory.Exists(Arguments.Il2cppDumpFiles) || File.Exists(Arguments.Il2cppDumpFiles + "/il2cpp.h")) { Parser.Default.ParseArguments <Options>(Array.Empty <string>()).WithParsed(_opts => Arguments = _opts); Console.ReadKey(); return; } string[] a = Directory.GetFiles(Arguments.Il2cppDumpFiles); ModuleContext modCtx = ModuleDef.CreateModuleContext(); var asmResolver = (AssemblyResolver)modCtx.AssemblyResolver; ModuleDefMD[] modules = a.Select(p => ModuleDefMD.Load(p, modCtx)).ToArray(); //modules = modules.OrderByDescending(x => x.Assembly.Name == "System"); foreach (var dll in modules) { asmResolver.AddToCache(dll); } var typeRefs = new Dictionary <string, List <TypeRef> >(); foreach (var module in modules) { foreach (var typeRef in module.GetTypeRefs()) { var tf = typeRef.ResolveTypeDef(); if (tf != null) { if (!typeRefs.TryGetValue($"{typeRef.DefinitionAssembly.Name}_{tf.FullName}", out var l)) { l = new List <TypeRef>(); typeRefs.Add($"{typeRef.DefinitionAssembly.Name}_{tf.FullName}", l); } l.Add(typeRef); } } } foreach (var module in modules) {
protected void PerformFieldCheck <TRef, TLocal>(params string[] expectedMessages) { var data = File.ReadAllBytes(typeof(TRef).Assembly.Location); var modCtx = ModuleDef.CreateModuleContext(); var module = ModuleDefMD.Load(data, modCtx); var refDef = module.GetTypes().Single(td => td.AssemblyQualifiedName == typeof(TRef).AssemblyQualifiedName); var localDef = module.GetTypes().Single(td => td.AssemblyQualifiedName == typeof(TLocal).AssemblyQualifiedName); var actualMessages = new List <string>(); foreach (IVersionRuleRunner runner in _integrationFixture.RuleRunners) { actualMessages.AddRange(runner.Analyze(refDef, localDef).Select(c => c.Message)); } AssertContentEqual(expectedMessages, actualMessages); }
public static void LoadModule(string filename) { try { FileName = filename; byte[] data = File.ReadAllBytes(filename); ModuleContext modCtx = ModuleDef.CreateModuleContext(); module = ModuleDefMD.Load(data, modCtx); Write("Module Loaded : " + module.Name, TypeMessage.Info); foreach (AssemblyRef dependance in module.GetAssemblyRefs()) { Write($"Dependance : {dependance.Name}", TypeMessage.Info); } } catch { Write("Error for Loade Module", TypeMessage.Error); } }
public DnSpyDecompiler() { this.files = new List <string>(); this.asmPaths = new List <string>(); this.userGacPaths = new List <string>(); this.gacFiles = new List <string>(); this.decompilationContext = new DecompilationContext(); this.moduleContext = ModuleDef.CreateModuleContext(true); this.assemblyResolver = (AssemblyResolver)moduleContext.AssemblyResolver; this.assemblyResolver.EnableTypeDefCache = true; this.bamlDecompiler = TryLoadBamlDecompiler(); this.decompileBaml = bamlDecompiler != null; this.reservedOptions = GetReservedOptions(); var langs = new List <ILanguage>(); langs.AddRange(GetAllLanguages()); langs.Sort((a, b) => a.OrderUI.CompareTo(b.OrderUI)); this.allLanguages = langs.ToArray(); }
public void CreateMod() { ModuleContext modCtx = ModuleDef.CreateModuleContext(); ModuleDefMD moddedModule = ModuleDefMD.Load(moddedAssembly, modCtx); ModuleDefMD originalModule = ModuleDefMD.Load(originalAssembly, modCtx); #region QuickAndDirtyRemoveLater var changedMethods = GetChangedMethods(moddedModule, originalModule); var output = ""; foreach (var method in changedMethods) { output += method.FullName + "\n"; } var addedTypesAndMethods = GetAddedTypesAndMethods(moddedModule, originalModule); output += "\n\nADDED TYPES: \n\n"; foreach (var addedType in addedTypesAndMethods.Item1) { output += addedType.FullName + "\n"; } output += "\n\nADDED METHODS: \n\n"; foreach (var addedMethod in addedTypesAndMethods.Item2) { output += addedMethod.FullName + "\n"; } File.WriteAllText(outFile, output); #endregion var save = CreateSave(moddedModule, originalModule); var json = JsonConvert.SerializeObject(save, Formatting.Indented); File.WriteAllText(outFile, json); }
IEnumerable <TypeDef> GetInjectedTypes() { var ev = new NetfuserEvent.InjectTypes(this); var mods = new ConcurrentDictionary <Assembly, ModuleDef>(); Fire(ev); if (ev.Types.Count == 0 && ev.TypeDefs.Count == 0) { return(Empty.Array <TypeDef>()); } var ctx = ModuleDef.CreateModuleContext(); foreach (var t in ev.Types) { var mod = mods.GetOrAdd(t.Assembly, a => ModuleDefMD.Load(a.Location, ctx)); var imp = new Importer(mod, ImporterOptions.TryToUseDefs); var tr = imp.Import(t); ev.TypeDefs.Add(tr.ResolveTypeDefThrow()); } return(ev.TypeDefs); }
static void Main(string[] args) { #region Read a .NET module from a file: // Create a default assembly resolver and type resolver and pass it to Load(). // If it's a .NET Core assembly, you'll need to disable GAC loading and add // .NET Core reference assembly search paths. ModuleContext modCtx = ModuleDef.CreateModuleContext(); ModuleDefMD module = ModuleDefMD.Load(MYEXE, modCtx); #endregion //#region Write PDB files //// Create a default assembly resolver and type resolver ////ModuleContext modCtx = ModuleDef.CreateModuleContext(); //var mod = ModuleDefMD.Load(MYEXE, modCtx); //// ... //var wopts = new dnlib.DotNet.Writer.ModuleWriterOptions(mod); //wopts.WritePdb = true; //wopts.PdbFileName = @"out.pdb"; // Set other file name //mod.Write(@"out.dll", wopts); //#endregion }
public void LoadMods(List <Mod> mods) { ModuleContext modCtx = ModuleDef.CreateModuleContext(); ModuleDefMD originalModule = ModuleDefMD.Load(originalAssembly, modCtx); // Restore Original originalModule.Write(output); mods.ForEach(mod => { if (mod.Active) { var jsonString = File.ReadAllText(mod.Path); Save save = JsonConvert.DeserializeObject <Save>(jsonString); InjectNewClasses(save, originalModule); InjectModdedMethods(save, originalModule); originalModule.Write(output); } }); }
public static Assembly LoadAssembly(byte[] assemblyData) { if (!Enabled) { return(Assembly.Load(assemblyData)); } using var input = new MemoryStream(assemblyData, writable: false); using var output = new MemoryStream(); var modCtx = ModuleDef.CreateModuleContext(); var module = ModuleDefMD.Load(input, modCtx); var realFullname = module.Assembly.FullName; if (s_Assemblies.ContainsKey(realFullname)) { s_Assemblies.Remove(realFullname); } var guid = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6); var name = $"{module.Assembly.Name}-{guid}"; module.Assembly.Name = name; module.Assembly.PublicKey = null; module.Assembly.HasPublicKey = false; module.Write(output); output.Seek(offset: 0, SeekOrigin.Begin); var newAssemblyData = output.ToArray(); var assembly = Assembly.Load(newAssemblyData); s_Assemblies.Add(realFullname, assembly); return(assembly); }
private static void Main(string[] args) { try { string path; if (args.Length != 1) { Console.WriteLine("Provide the location of Assembly-CSharp.dll:"); path = Console.ReadLine(); } else { path = args[0]; } ModuleDefMD module = ModuleDefMD.Load(path); if (module == null) { Console.WriteLine($"File {path} not found!"); return; } Console.WriteLine($"Loaded {module.Name}"); Console.WriteLine("Resolving References..."); module.Context = ModuleDef.CreateModuleContext(); ((AssemblyResolver)module.Context.AssemblyResolver).AddToCache(module); Console.WriteLine("Injecting the Bootstrap Class."); ModuleDefMD bootstrap = ModuleDefMD.Load(Path.Combine(Directory.GetCurrentDirectory(), "Exiled.Bootstrap.dll")); Console.WriteLine("Loaded " + bootstrap.Name); TypeDef modClass = bootstrap.Types[0]; foreach (var type in bootstrap.Types) { if (type.Name == "Bootstrap") { modClass = type; Console.WriteLine($"[Injection] Hooked to: \"{type.Namespace}.{type.Name}\""); } } var modRefType = modClass; bootstrap.Types.Remove(modClass); modRefType.DeclaringType = null; module.Types.Add(modRefType); MethodDef call = FindMethod(modRefType, "Load"); if (call == null) { Console.WriteLine($"Failed to get the \"{call.Name}\" method! Maybe you don't have permission?"); return; } Console.WriteLine("Injected!"); Console.WriteLine("Injection completed!"); Console.WriteLine("Patching code..."); TypeDef typeDef = FindType(module.Assembly, "ServerConsole"); MethodDef start = FindMethod(typeDef, "Start"); if (start == null) { start = new MethodDefUser("Start", MethodSig.CreateInstance(module.CorLibTypes.Void), MethodImplAttributes.IL | MethodImplAttributes.Managed, MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); typeDef.Methods.Add(start); } start.Body.Instructions.Insert(0, OpCodes.Call.ToInstruction(call)); module.Write(Path.Combine(Path.GetDirectoryName(Path.GetFullPath(path)), "Assembly-CSharp-Exiled.dll")); Console.WriteLine("Patching completed successfully!"); } catch (Exception exception) { Console.WriteLine($"An error has occurred while patching: {exception}"); } Console.Read(); }
private void Button_Click(object sender, RoutedEventArgs e) { var time = DateTime.Now.ToString("hh:mm:ss"); ModuleContext modCtx = ModuleDef.CreateModuleContext(); var module = ModuleDefMD.Load(Program.Text, modCtx); ConsoleLog.Foreground = Brushes.Black; ConsoleLog.AppendText($"{time} Starting obfuscation{Environment.NewLine}"); if (String_Encryption.IsChecked == true) { StringEncPhase.Execute(module); ConsoleLog.AppendText($"{time} Processing string encryption{Environment.NewLine}"); } if (Online_Decryption.IsChecked == true) { OnlinePhase.Execute(module); ConsoleLog.AppendText($"{time} Processing online decryption{Environment.NewLine}"); } if (Cflow.IsChecked == true) { ControlFlowObfuscation.Execute(module); ConsoleLog.AppendText($"{time} Processing control flow{Environment.NewLine}"); } if (IntConf.IsChecked == true) { AddIntPhase.Execute2(module); ConsoleLog.AppendText($"{time} Processing integer confusion{Environment.NewLine}"); } if (SUC.IsChecked == true) { StackUnfConfusion.Execute(module); ConsoleLog.AppendText($"{time} Processing stack confusion{Environment.NewLine}"); } if (Ahri.IsChecked == true) { Arithmetic.Execute(module); ConsoleLog.AppendText($"{time} Processing math calculations{Environment.NewLine}"); } if (LF.IsChecked == true) { L2F.Execute(module); ConsoleLog.AppendText($"{time} Processing constant fields{Environment.NewLine}"); } if (LFV2.IsChecked == true) { L2FV2.Execute(module); ConsoleLog.AppendText($"{time} Processing local fields{Environment.NewLine}"); } if (Calli_.IsChecked == true) { Calli.Execute(module); ConsoleLog.AppendText($"{time} Processing calli conversion{Environment.NewLine}"); } if (Proxy_String.IsChecked == true) { ProxyString.Execute(module); ConsoleLog.AppendText($"{time} Processing proxy strings{Environment.NewLine}"); } if (ProxyConstants.IsChecked == true) { ProxyINT.Execute(module); ConsoleLog.AppendText($"{time} Processing proxy constants{Environment.NewLine}"); } if (Proxy_Meth.IsChecked == true) { ProxyMeth.Execute(module); ConsoleLog.AppendText($"{time} Processing proxy methods{Environment.NewLine}"); } if (Anti_De4dot.IsChecked == true) { AntiDecompile.Execute(module.Assembly); ConsoleLog.AppendText($"{time} Processing anti-decompile{Environment.NewLine}"); } if (JumpCflow.IsChecked == true) { JumpCFlow.Execute(module); ConsoleLog.AppendText($"{time} Processing flow conversion{Environment.NewLine}"); } if (AntiDebug.IsChecked == true) { Anti_Debug.Execute(module); ConsoleLog.AppendText($"{time} Processing anti-debug{Environment.NewLine}"); } if (Anti_Dump.IsChecked == true) { AntiDump.Execute(module); ConsoleLog.AppendText($"{time} Processing anti-dump{Environment.NewLine}"); } if (AntiTamper.IsChecked == true) { Protection.Software.AntiTamper.Execute(module); ConsoleLog.AppendText($"{time} Processing anti-tamper{Environment.NewLine}"); } if (InvalidMD.IsChecked == true) { InvalidMDPhase.Execute(module.Assembly); ConsoleLog.AppendText($"{time} Processing invalid metadata{Environment.NewLine}"); } var text2 = Path.GetDirectoryName(Program.Text); if (text2 != null && !text2.EndsWith("\\")) { text2 += "\\"; } var path = $"{text2}{Path.GetFileNameWithoutExtension(Program.Text)}_protected{Path.GetExtension(Program.Text)}"; module.Write(path, new ModuleWriterOptions(module) { PEHeadersOptions = { NumberOfRvaAndSizes = 13 }, Logger = DummyLogger.NoThrowInstance }); ConsoleLog.AppendText($"{time} File: {path}{Environment.NewLine}{Environment.NewLine}"); if (AntiTamper.IsChecked == true) { Protection.Software.AntiTamper.Sha256(path); } }
public static int Main(string[] args) { if (args.Length < 2) { return(XConsole.WriteLine("NameMapper.CLI - map names from assembly with deobfuscated names to assembly with obfuscated names\n" + "by exys, 2019\n" + "\n" + "Usage:\n" + "NameMapper.CLI [clean module] [obfuscated module]")); } if (!File.Exists(_cleanModulePath = Path.GetFullPath(args[0]))) { return(XConsole.PrintError("Specified clean module path does not exist")); } if (!File.Exists(_obfModulePath = Path.GetFullPath(args[1]))) { return(XConsole.PrintError("Specified obfuscated module path does not exist")); } try { _cleanModule = ModuleDefMD.Load(_cleanModulePath, ModuleDef.CreateModuleContext()); _obfModule = ModuleDefMD.Load(_obfModulePath, ModuleDef.CreateModuleContext()); } catch (Exception e) { return(XConsole.PrintError("An error occurred while trying to load and process modules! Details:\n" + e)); } XConsole.PrintInfo($"Loaded modules: {_cleanModule.Assembly.FullName} (clean); {_obfModule.Assembly.FullName} (obfuscated)."); var fancyOut = new ConcurrentQueue <string>(); // ReSharper disable once FunctionNeverReturns ThreadPool.QueueUserWorkItem(state => { while (true) { if (!fancyOut.IsEmpty && fancyOut.TryDequeue(out string msg)) { XConsole.Write(msg); } Thread.Sleep(1); } }); NameMapper nameMapper = new NameMapper(_cleanModule, _obfModule, fancyOut); nameMapper.BeginProcessing(); string filename = Path.GetFileNameWithoutExtension(_obfModulePath) + "-nmapped" + Path.GetExtension(_obfModulePath); XConsole.PrintInfo("Finally writing module back (with \"-nmapped\" tag)!"); _obfModule.Write( Path.Combine( Path.GetDirectoryName(_obfModulePath) ?? throw new NameMapperCliException("Path to write module to is null unexpectedly"), filename), new ModuleWriterOptions(_obfModule) { MetadataOptions = { Flags = DEFAULT_METADATA_FLAGS } }); Console.ReadKey(true); return(0); }
/// <summary> /// This Program is used to compile the Assembly-CSharp. /// /// For Instruction on how to use this Program please check the readme of this Project. /// </summary> public static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Missing File Argument"); return; } var module = ModuleDefMD.Load(args[0]); if (module == null) { Console.WriteLine("File Not Found"); return; } module.IsILOnly = true; module.VTableFixups = null; module.Assembly.PublicKey = null; module.Assembly.HasPublicKey = false; var opts = new ModuleWriterOptions(module); Console.WriteLine($"Synapse: Loaded {module.Name}"); Console.WriteLine("Synapse-Assemble: Resolving Ref.."); var modCtx = ModuleDef.CreateModuleContext(); var asmResolver = (AssemblyResolver)modCtx.AssemblyResolver; module.Context = modCtx; ((AssemblyResolver)module.Context.AssemblyResolver).AddToCache(module); Console.WriteLine("Synapse-Injection: Injection of ModLoader"); var modLoader = ModuleDefMD.Load("SynapseModLoader.dll"); Console.WriteLine($"Synapse-Inject: Loaded {modLoader.Name}"); var modClass = modLoader.Types[0]; foreach (var type in modLoader.Types) { if (type.Name != "ModLoader") { continue; } modClass = type; Console.WriteLine($"Synapse-Inject: Hooked to: {type.Namespace}.{type.Name}"); } var modRefType = modClass; modLoader.Types.Remove(modClass); modRefType.DeclaringType = null; module.Types.Add(modRefType); var call = FindMethod(modRefType, "LoadModSystem"); if (call == null) { Console.WriteLine("Failed to get 'LoadModSystem'. Perm Err?"); return; } Console.WriteLine("Synapse-Inject: Injected!"); Console.WriteLine("Synapse: Patching..."); var def = FindType(module.Assembly, "ServerConsoleSender"); // ReSharper disable once IdentifierTypo MethodDef bctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), MethodImplAttributes.IL | MethodImplAttributes.Managed, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); if (FindMethod(def, ".ctor") != null) { bctor = FindMethod(def, ".ctor"); Console.WriteLine("Synapse: Re-using constructor."); } else { def.Methods.Add(bctor); } CilBody body; bctor.Body = body = new CilBody(); body.Instructions.Add(OpCodes.Call.ToInstruction(call)); body.Instructions.Add(OpCodes.Ret.ToInstruction()); module.Write("Assembly-CSharp-Synapse.dll"); Console.WriteLine("Synapse: Patch Complete!"); var publicModule = ModuleDefMD.Load("Assembly-CSharp-Synapse.dll"); Console.WriteLine("Synapse-Public: Creating Publicized DLL"); var allTypes = GetAllTypes(publicModule.Assembly.ManifestModule); var typeDefs = allTypes.ToList(); var allMethods = typeDefs.SelectMany(t => t.Methods); var allFields = typeDefs.SelectMany(t => t.Fields); #region Publiczing foreach (var type in typeDefs.Where(type => !type?.IsPublic ?? false)) { type.Attributes = type.IsNested ? TypeAttributes.NestedPublic : TypeAttributes.Public; } foreach (var method in allMethods) { if (!method?.IsPublic ?? false) { method.Access = MethodAttributes.Public; } } foreach (var field in allFields) { if (!field?.IsPublic ?? false) { field.Access = FieldAttributes.Public; } } #endregion publicModule.Write("Assembly-CSharp-Synapse_publicised.dll"); Console.WriteLine("Synapse-Public: Created Publicised DLL"); Thread.Sleep(1000000000); }
public static void Publicize(string input, string output = null) { output ??= DefaultOutputDir + Path.DirectorySeparatorChar; if (string.IsNullOrEmpty(Path.GetFileName(output))) { output = Path.Combine(output, Path.GetFileNameWithoutExtension(input) + Suffix + Path.GetExtension(input)); } if (!File.Exists(input)) { Console.WriteLine(); Console.WriteLine("ERROR! File doesn't exist or you don't have sufficient permissions."); Environment.Exit(30); } ModuleDefMD module = null; try { module = ModuleDefMD.Load(input, ModuleDef.CreateModuleContext()); } catch (Exception e) { Console.WriteLine(); Console.WriteLine("ERROR! Cannot read the assembly. Please check your permissions."); Console.WriteLine(e); Environment.Exit(40); } var runtimeVisibilityAttribute = new TypeDefUser("RuntimeVisibilityAttribute", module.Import(typeof(Attribute))) { Attributes = TypeAttributes.Class & TypeAttributes.Public }; module.Types.Add(runtimeVisibilityAttribute); runtimeVisibilityAttribute.Methods.Add(new MethodDefUser( ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void, module.CorLibTypes.String), MethodImplAttributes.Managed & MethodImplAttributes.IL, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName) { ParamDefs = { new ParamDefUser("visibility") } } ); var allTypes = module.GetTypes().ToList(); var types = 0; var methods = 0; var fields = 0; foreach (var type in allTypes) { foreach (var method in type.Methods) { if (method.IsPublic) { continue; } methods++; method.CustomAttributes.Add( new CustomAttribute(runtimeVisibilityAttribute.FindConstructors().Single(), new[] { new CAArgument(module.CorLibTypes.String, method.Access.ToString()) }) ); method.Access = MethodAttributes.Public; } foreach (var field in type.Fields) { if (field.IsPublic) { continue; } fields++; field.CustomAttributes.Add( new CustomAttribute(runtimeVisibilityAttribute.FindConstructors().Single(), new[] { new CAArgument(module.CorLibTypes.String, field.Access.ToString()) }) ); field.Access = FieldAttributes.Public; } if (type.IsNested ? type.IsNestedPublic : type.IsPublic) { continue; } types++; type.CustomAttributes.Add( new CustomAttribute(runtimeVisibilityAttribute.FindConstructors().Single(), new[] { new CAArgument(module.CorLibTypes.String, type.Visibility.ToString()) }) ); type.Visibility = type.IsNested ? TypeAttributes.NestedPublic : TypeAttributes.Public; } const string reportString = "Changed {0} {1} to public."; Console.WriteLine(reportString, types, "types"); Console.WriteLine(reportString, methods, "methods (including getters and setters)"); Console.WriteLine(reportString, fields, "fields"); Console.WriteLine(); Console.WriteLine("Saving a copy of the modified assembly ..."); try { var directory = Path.GetDirectoryName(output); if (!string.IsNullOrEmpty(directory)) { Directory.CreateDirectory(directory); } module.Write(output); } catch (Exception e) { Console.WriteLine(); Console.WriteLine("ERROR! Cannot create/overwrite the new assembly. "); Console.WriteLine("Please check the path and its permissions " + "and in case of overwriting an existing file ensure that it isn't currently used."); Console.WriteLine(e); Environment.Exit(50); } Console.WriteLine("Completed."); }