/// <summary> /// Protects the stub using original project settings replace the current output with the protected stub. /// </summary> /// <param name="context">The working context.</param> /// <param name="fileName">The result file name.</param> /// <param name="module">The stub module.</param> /// <param name="snKey">The strong name key.</param> /// <param name="prot">The packer protection that applies to the stub.</param> protected void ProtectStub(ConfuserContext context, string fileName, byte[] module, StrongNameKey snKey, Protection prot = null) { string tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); string outDir = Path.Combine(tmpDir, Path.GetRandomFileName()); Directory.CreateDirectory(tmpDir); File.WriteAllBytes(Path.Combine(tmpDir, fileName), module); var proj = new ConfuserProject(); proj.Seed = context.Project.Seed; foreach (Rule rule in context.Project.Rules) { proj.Rules.Add(rule); } proj.Add(new ProjectModule { Path = fileName }); proj.BaseDirectory = tmpDir; proj.OutputDirectory = outDir; PluginDiscovery discovery = null; if (prot != null) { var rule = new Rule { Preset = ProtectionPreset.None, Inherit = true, Pattern = "true" }; rule.Add(new SettingItem <Protection> { Id = prot.Id, Action = SettingItemAction.Add }); proj.Rules.Add(rule); discovery = new PackerDiscovery(prot); } try { ConfuserEngine.Run(new ConfuserParameters { Logger = new PackerLogger(context.Logger), PluginDiscovery = discovery, Marker = new PackerMarker(snKey), Project = proj, PackerInitiated = true }, context.token).Wait(); } catch (AggregateException ex) { context.Logger.Error("Failed to protect packer stub."); throw new ConfuserException(ex); } context.OutputModules = new[] { File.ReadAllBytes(Path.Combine(outDir, fileName)) }; context.OutputPaths = new[] { fileName }; }
/// <summary> /// Runs the engine with the specified parameters. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="token">The token used for cancellation.</param> /// <returns>Task to run the engine.</returns> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="parameters" />.Project is <c>null</c>. /// </exception> // Token: 0x06000109 RID: 265 RVA: 0x00008830 File Offset: 0x00006A30 public static Task Run(ConfuserParameters parameters, CancellationToken?token = null) { if (parameters.Project == null) { throw new ArgumentNullException("parameters"); } if (!token.HasValue) { token = new CancellationToken?(new CancellationTokenSource().Token); } return(Task.Factory.StartNew(delegate { ConfuserEngine.RunInternal(parameters, token.Value); }, token.Value)); }
/// <summary> /// Prints the environment information when error occurred. /// </summary> /// <param name="context">The working context.</param> // Token: 0x06000117 RID: 279 RVA: 0x0000A430 File Offset: 0x00008630 private static void PrintEnvironmentInfo(ConfuserContext context) { if (context.PackerInitiated) { return; } context.Logger.Error("---BEGIN DEBUG INFO---"); context.Logger.Error("Installed Framework Versions:"); foreach (string ver in ConfuserEngine.GetFrameworkVersions()) { context.Logger.ErrorFormat(" {0}", new object[] { ver.Trim() }); } context.Logger.Error(""); if (context.Resolver != null) { context.Logger.Error("Cached assemblies:"); foreach (AssemblyDef asm in context.Resolver.GetCachedAssemblies()) { if (string.IsNullOrEmpty(asm.ManifestModule.Location)) { context.Logger.ErrorFormat(" {0}", new object[] { asm.FullName }); } else { context.Logger.ErrorFormat(" {0} ({1})", new object[] { asm.FullName, asm.ManifestModule.Location }); } foreach (AssemblyRef reference in asm.Modules.OfType <ModuleDefMD>().SelectMany((ModuleDefMD m) => m.GetAssemblyRefs())) { context.Logger.ErrorFormat(" {0}", new object[] { reference.FullName }); } } } context.Logger.Error("---END DEBUG INFO---"); }
/// <summary> /// Runs the engine. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="token">The cancellation token.</param> // Token: 0x0600010A RID: 266 RVA: 0x000088B4 File Offset: 0x00006AB4 private static void RunInternal(ConfuserParameters parameters, CancellationToken token) { ConfuserContext context = new ConfuserContext(); context.Logger = parameters.GetLogger(); context.Project = parameters.Project; context.PackerInitiated = parameters.PackerInitiated; context.token = token; ConfuserEngine.PrintInfo(context); bool ok = false; try { AssemblyResolver asmResolver = new AssemblyResolver(); asmResolver.EnableTypeDefCache = true; asmResolver.DefaultModuleContext = new ModuleContext(asmResolver); context.Resolver = asmResolver; context.BaseDirectory = Path.Combine(Environment.CurrentDirectory, parameters.Project.BaseDirectory.TrimEnd(new char[] { Path.DirectorySeparatorChar }) + Path.DirectorySeparatorChar); context.OutputDirectory = Path.Combine(parameters.Project.BaseDirectory, parameters.Project.OutputDirectory.TrimEnd(new char[] { Path.DirectorySeparatorChar }) + Path.DirectorySeparatorChar); foreach (string probePath in parameters.Project.ProbePaths) { asmResolver.PostSearchPaths.Insert(0, Path.Combine(context.BaseDirectory, probePath)); } context.CheckCancellation(); Marker marker = parameters.GetMarker(); context.Logger.Debug("Discovering plugins..."); IList <Protection> prots; IList <Packer> packers; IList <ConfuserComponent> components; parameters.GetPluginDiscovery().GetPlugins(context, out prots, out packers, out components); context.Logger.InfoFormat("Discovered {0} protections, {1} packers.", new object[] { prots.Count, packers.Count }); context.CheckCancellation(); context.Logger.Debug("Resolving component dependency..."); try { DependencyResolver resolver = new DependencyResolver(prots); prots = resolver.SortDependency(); } catch (CircularDependencyException ex) { context.Logger.ErrorException("", ex); throw new ConfuserException(ex); } components.Insert(0, new CoreComponent(parameters, marker)); foreach (Protection prot in prots) { components.Add(prot); } foreach (Packer packer in packers) { components.Add(packer); } context.CheckCancellation(); context.Logger.Info("Loading input modules..."); marker.Initalize(prots, packers); MarkerResult markings = marker.MarkProject(parameters.Project, context); context.Modules = markings.Modules.ToList <ModuleDefMD>().AsReadOnly(); foreach (ModuleDefMD module in context.Modules) { module.EnableTypeDefFindCache = true; } context.OutputModules = Enumerable.Repeat <byte[]>(null, markings.Modules.Count).ToArray <byte[]>(); context.OutputSymbols = Enumerable.Repeat <byte[]>(null, markings.Modules.Count).ToArray <byte[]>(); context.OutputPaths = Enumerable.Repeat <string>(null, markings.Modules.Count).ToArray <string>(); context.Packer = markings.Packer; context.ExternalModules = markings.ExternalModules; context.CheckCancellation(); context.Logger.Info("Initializing..."); foreach (ConfuserComponent comp in components) { try { comp.Initialize(context); } catch (Exception ex2) { context.Logger.ErrorException("Error occured during initialization of '" + comp.Name + "'.", ex2); throw new ConfuserException(ex2); } context.CheckCancellation(); } context.CheckCancellation(); context.Logger.Debug("Building pipeline..."); ProtectionPipeline pipeline = new ProtectionPipeline(); context.Pipeline = pipeline; foreach (ConfuserComponent comp2 in components) { comp2.PopulatePipeline(pipeline); } context.CheckCancellation(); ConfuserEngine.RunPipeline(pipeline, context); ok = true; } catch (AssemblyResolveException ex3) { context.Logger.ErrorException("Failed to resolve an assembly, check if all dependencies are present in the correct version.", ex3); ConfuserEngine.PrintEnvironmentInfo(context); } catch (TypeResolveException ex4) { context.Logger.ErrorException("Failed to resolve a type, check if all dependencies are present in the correct version.", ex4); ConfuserEngine.PrintEnvironmentInfo(context); } catch (MemberRefResolveException ex5) { context.Logger.ErrorException("Failed to resolve a member, check if all dependencies are present in the correct version.", ex5); ConfuserEngine.PrintEnvironmentInfo(context); } catch (IOException ex6) { context.Logger.ErrorException("An IO error occurred, check if all input/output locations are readable/writable.", ex6); } catch (OperationCanceledException) { context.Logger.Error("Operation cancelled."); } catch (ConfuserException) { } catch (Exception ex7) { context.Logger.ErrorException("Unknown error occurred.", ex7); } finally { if (context.Resolver != null) { context.Resolver.Clear(); } context.Logger.Finish(ok); } }
/// <summary> /// Protects the stub using original project settings replace the current output with the protected stub. /// </summary> /// <param name="context">The working context.</param> /// <param name="fileName">The result file name.</param> /// <param name="module">The stub module.</param> /// <param name="snKey">The strong name key.</param> /// <param name="prot">The packer protection that applies to the stub.</param> // Token: 0x060001E8 RID: 488 RVA: 0x0000F8AC File Offset: 0x0000DAAC protected void ProtectStub(ConfuserContext context, string fileName, byte[] module, StrongNameKey snKey, Protection prot = null) { string tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); string outDir = Path.Combine(tmpDir, Path.GetRandomFileName()); Directory.CreateDirectory(tmpDir); for (int i = 0; i < context.OutputModules.Count; i++) { string path = Path.GetFullPath(Path.Combine(tmpDir, context.OutputPaths[i])); string dir = Path.GetDirectoryName(path); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } File.WriteAllBytes(path, context.OutputModules[i]); } File.WriteAllBytes(Path.Combine(tmpDir, fileName), module); ConfuserProject proj = new ConfuserProject(); proj.Seed = context.Project.Seed; foreach (Rule rule in context.Project.Rules) { proj.Rules.Add(rule); } proj.Add(new ProjectModule { Path = fileName }); proj.BaseDirectory = tmpDir; proj.OutputDirectory = outDir; foreach (string path2 in context.Project.ProbePaths) { proj.ProbePaths.Add(path2); } proj.ProbePaths.Add(context.Project.BaseDirectory); PluginDiscovery discovery = null; if (prot != null) { Rule rule2 = new Rule("true", ProtectionPreset.None, false) { Preset = ProtectionPreset.None, Inherit = true, Pattern = "true" }; rule2.Add(new SettingItem <Protection>(null, SettingItemAction.Add) { Id = prot.Id, Action = SettingItemAction.Add }); proj.Rules.Add(rule2); discovery = new PackerDiscovery(prot); } try { ConfuserEngine.Run(new ConfuserParameters { Logger = new PackerLogger(context.Logger), PluginDiscovery = discovery, Marker = new PackerMarker(snKey), Project = proj, PackerInitiated = true }, new CancellationToken?(context.token)).Wait(); } catch (AggregateException ex) { context.Logger.Error("Failed to protect packer stub."); throw new ConfuserException(ex); } context.OutputModules = new byte[][] { File.ReadAllBytes(Path.Combine(outDir, fileName)) }; context.OutputPaths = new string[] { fileName }; }
/// <summary> /// Protects the stub using original project settings replace the current output with the protected stub. /// </summary> /// <param name="context">The working context.</param> /// <param name="fileName">The result file name.</param> /// <param name="module">The stub module.</param> /// <param name="snKey">The strong name key.</param> /// <param name="prot">The packer protection that applies to the stub.</param> protected void ProtectStub(ConfuserContext context, string fileName, byte[] module, StrongNameKey snKey, StrongNamePublicKey snPubKey, StrongNameKey snSigKey, StrongNamePublicKey snPubSigKey, bool snDelaySig, Protection prot = null) { string tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); try { string outDir = Path.Combine(tmpDir, Path.GetRandomFileName()); Directory.CreateDirectory(tmpDir); for (int i = 0; i < context.OutputModules.Count; i++) { string path = Path.GetFullPath(Path.Combine(tmpDir, context.OutputPaths[i])); var dir = Path.GetDirectoryName(path); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } File.WriteAllBytes(path, context.OutputModules[i]); } File.WriteAllBytes(Path.Combine(tmpDir, fileName), module); var proj = new ConfuserProject(); proj.Seed = context.Project.Seed; foreach (Rule rule in context.Project.Rules) { proj.Rules.Add(rule); } proj.Add(new ProjectModule { Path = fileName }); proj.BaseDirectory = tmpDir; proj.OutputDirectory = outDir; foreach (var path in context.Project.ProbePaths) { proj.ProbePaths.Add(path); } proj.ProbePaths.Add(context.Project.BaseDirectory); PluginDiscovery discovery = null; if (prot != null) { var rule = new Rule { Preset = ProtectionPreset.None, Inherit = true, Pattern = "true" }; rule.Add(new SettingItem <Protection> { Id = prot.Id, Action = SettingItemAction.Add }); proj.Rules.Add(rule); discovery = new PackerDiscovery(prot); } try { ConfuserEngine .Run( new ConfuserParameters { Logger = new PackerLogger(context.Logger), PluginDiscovery = discovery, Marker = new PackerMarker(snKey, snPubKey, snDelaySig, snSigKey, snPubSigKey), Project = proj, PackerInitiated = true }, context.token).Wait(); } catch (AggregateException ex) { context.Logger.Error("Failed to protect packer stub."); throw new ConfuserException(ex); } context.OutputModules = new[] { File.ReadAllBytes(Path.Combine(outDir, fileName)) }; context.OutputPaths = new[] { fileName }; } finally { try { if (Directory.Exists(tmpDir)) { Directory.Delete(tmpDir, true); } } catch (IOException ex) { context.Logger.WarnException("Failed to remove temporary files of packer.", ex); } } }