PHXH
/
obfuz
mirror of https://github.com/focus-creative-games/obfuz
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

重构 ObfuscatorBuilder

backup
walon 2025-05-03 21:43:50 +08:00
parent 87dd8a39c1
commit c30abd5977
9 changed files with 184 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Editor/BuildProcess/ObfuzProcess.cs
View File

@ -100,10 +100,9 @@ namespace Obfuz
string applicationContentsPath = EditorApplication.applicationContentsPath;
var opt = new Obfuscator.Options
{
obfuscationAssemblyNames = settings.obfuscationAssemblyNames.ToList(),
assemblySearchDirs = new List<string>
var obfuscatorBuilder = ObfuscatorBuilder.FromObfuzSettings(settings, buildTarget);
var assemblySearchDirs = new List<string>
{
#if UNITY_2021_1_OR_NEWER
Path.Combine(applicationContentsPath, "UnityReferenceAssemblies/unity-4.8-api/Facades"),
@ -116,17 +115,15 @@ namespace Obfuz
#endif
Path.Combine(applicationContentsPath, "Managed/UnityEngine"),
backupPlayerScriptAssembliesPath,
}.Concat(settings.extraAssemblySearchDirs).ToList(),
obfuscationRuleFiles = settings.ruleFiles.ToList(),
mappingXmlPath = settings.mappingFile,
outputDir = obfuscatedAssemblyOutputDir,
};
var obfuz = new Obfuscator(opt);
obfuscatorBuilder.InsertTopPriorityAssemblySearchDirs(assemblySearchDirs);
Obfuscator obfuz = obfuscatorBuilder.Build();
obfuz.Run();
foreach (var dllName in settings.obfuscationAssemblyNames)
foreach (var dllName in settings.toObfuscatedAssemblyNames)
{
string src = $"{opt.outputDir}/{dllName}.dll";
string src = $"{obfuscatorBuilder.ObfuscatedAssemblyOutputDir}/{dllName}.dll";
string dst = $"{scriptAssembliesPath}/{dllName}.dll";
if (!File.Exists(src))

79
Editor/Obfuscator.cs
View File

@ -1,8 +1,4 @@
using dnlib.DotNet;
using Obfuz.DynamicProxy;
using Obfuz.ExprObfuscation;
using Obfuz.MemEncrypt;
using Obfuz.Rename;
using Obfuz.Emit;
using System;
using System.Collections.Generic;
@ -11,49 +7,47 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using Obfuz.Virtualization;
namespace Obfuz
{
public class Obfuscator
{
public class Options
{
public List<string> obfuscationAssemblyNames;
public List<string> assemblySearchDirs;
public List<string> obfuscationRuleFiles;
public string mappingXmlPath;
public string outputDir;
}
private readonly Options _options;
private readonly string _obfuscatedAssemblyOutputDir;
private readonly AssemblyCache _assemblyCache;
private readonly List<ObfuzAssemblyInfo> _obfuzAssemblies = new List<ObfuzAssemblyInfo>();
private readonly List<string> _obfuscationAssemblyNames;
public IList<string> ObfuscationAssemblyNames => _obfuscationAssemblyNames;
private readonly List<string> _toObfuscatedAssemblyNames;
private readonly List<string> _notObfuscatedAssemblyNamesReferencingObfuscated;
private readonly ObfuzPipeline _pipeline = new ObfuzPipeline();
private readonly ObfuscatorContext _ctx;
public Obfuscator(Options options)
public Obfuscator(List<string> toObfuscatedAssemblyNames,
List<string> notObfuscatedAssemblyNamesReferencingObfuscated,
List<string> assemblySearchDirs,
string obfuscatedAssemblyOutputDir,
List<IObfuscationPass> obfuscationPasses)
{
_options = options;
_obfuscationAssemblyNames = options.obfuscationAssemblyNames;
MetadataImporter.Reset();
_assemblyCache = new AssemblyCache(new PathAssemblyResolver(options.assemblySearchDirs.ToArray()));
_toObfuscatedAssemblyNames = toObfuscatedAssemblyNames;
_notObfuscatedAssemblyNamesReferencingObfuscated = notObfuscatedAssemblyNamesReferencingObfuscated;
_obfuscatedAssemblyOutputDir = obfuscatedAssemblyOutputDir;
_pipeline.AddPass(new MemoryEncryptionPass());
//_pipeline.AddPass(new ProxyCallPass());
_pipeline.AddPass(new ExprObfuscationPass());
_pipeline.AddPass(new DataVirtualizationPass());
_pipeline.AddPass(new RenameSymbolPass());
MetadataImporter.Reset();
_assemblyCache = new AssemblyCache(new PathAssemblyResolver(assemblySearchDirs.ToArray()));
foreach (var pass in obfuscationPasses)
{
_pipeline.AddPass(pass);
}
//_pipeline.AddPass(new MemoryEncryptionPass());
////_pipeline.AddPass(new ProxyCallPass());
//_pipeline.AddPass(new ExprObfuscationPass());
//_pipeline.AddPass(new DataVirtualizationPass());
//_pipeline.AddPass(new RenameSymbolPass());
_pipeline.AddPass(new CleanUpInstructionPass());
@ -61,25 +55,29 @@ namespace Obfuz
{
assemblyCache = _assemblyCache,
assemblies = _obfuzAssemblies,
obfuscationAssemblyNames = _obfuscationAssemblyNames,
obfuscationRuleFiles = options.obfuscationRuleFiles,
mappingXmlPath = _options.mappingXmlPath,
outputDir = options.outputDir,
toObfuscatedAssemblyNames = _toObfuscatedAssemblyNames,
notObfuscatedAssemblyNamesReferencingObfuscated = _notObfuscatedAssemblyNamesReferencingObfuscated,
obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir,
};
}
public void Run()
{
OnPreObfuscation();
DoObfuscation();
OnPostObfuscation();
}
private void OnPreObfuscation()
{
LoadAssemblies();
_pipeline.Start(_ctx);
DoObfuscation();
OnObfuscationFinished();
}
private void LoadAssemblies()
{
foreach (string assName in _obfuscationAssemblyNames)
foreach (string assName in _toObfuscatedAssemblyNames)
{
ModuleDefMD mod = _assemblyCache.TryLoadModule(assName);
if (mod == null)
@ -114,21 +112,18 @@ namespace Obfuz
private void DoObfuscation()
{
string outputDir = _options.outputDir;
FileUtil.RecreateDir(outputDir);
FileUtil.RecreateDir(_obfuscatedAssemblyOutputDir);
_pipeline.Run(_ctx);
}
private void OnObfuscationFinished()
private void OnPostObfuscation()
{
string outputDir = _options.outputDir;
_pipeline.Stop(_ctx);
foreach (var ass in _obfuzAssemblies)
{
string outputFile = $"{outputDir}/{ass.module.Name}";
string outputFile = $"{_obfuscatedAssemblyOutputDir}/{ass.module.Name}";
ass.module.Write(outputFile);
Debug.Log($"save module. oldName:{ass.name} newName:{ass.module.Name} output:{outputFile}");
}

82
Editor/ObfuscatorBuilder.cs Normal file
View File

@ -0,0 +1,82 @@
using Obfuz.DynamicProxy;
using Obfuz.ExprObfuscation;
using Obfuz.MemEncrypt;
using Obfuz.Rename;
using System.Collections.Generic;
using System.Linq;
using Obfuz.Virtualization;
using UnityEditor;
namespace Obfuz
{
public class ObfuscatorBuilder
{
private List<string> _toObfuscatedAssemblyNames = new List<string>();
private List<string> _notObfuscatedAssemblyNamesReferencingObfuscated = new List<string>();
private List<string> _assemblySearchDirs = new List<string>();
private string _obfuscatedAssemblyOutputDir;
private List<IObfuscationPass> _obfuscationPasses = new List<IObfuscationPass>();
public List<string> ToObfuscatedAssemblyNames
{
get => _toObfuscatedAssemblyNames;
set => _toObfuscatedAssemblyNames = value;
}
public List<string> NotObfuscatedAssemblyNamesReferencingObfuscated
{
get => _notObfuscatedAssemblyNamesReferencingObfuscated;
set => _notObfuscatedAssemblyNamesReferencingObfuscated = value;
}
public List<string> AssemblySearchDirs
{
get => _assemblySearchDirs;
set => _assemblySearchDirs = value;
}
public string ObfuscatedAssemblyOutputDir
{
get => _obfuscatedAssemblyOutputDir;
set => _obfuscatedAssemblyOutputDir = value;
}
public void InsertTopPriorityAssemblySearchDirs(List<string> assemblySearchDirs)
{
_assemblySearchDirs.InsertRange(0, assemblySearchDirs);
}
public ObfuscatorBuilder AddPass(IObfuscationPass pass)
{
_obfuscationPasses.Add(pass);
return this;
}
public Obfuscator Build()
{
return new Obfuscator(_toObfuscatedAssemblyNames,
_notObfuscatedAssemblyNamesReferencingObfuscated,
_assemblySearchDirs,
_obfuscatedAssemblyOutputDir,
_obfuscationPasses);
}
public static ObfuscatorBuilder FromObfuzSettings(ObfuzSettings settings, BuildTarget target)
{
var builder = new ObfuscatorBuilder
{
_toObfuscatedAssemblyNames = settings.toObfuscatedAssemblyNames.ToList(),
_notObfuscatedAssemblyNamesReferencingObfuscated = settings.notObfuscatedAssemblyNamesReferencingObfuscated.ToList(),
_assemblySearchDirs = settings.extraAssemblySearchDirs.ToList(),
_obfuscatedAssemblyOutputDir = settings.GetObfuscatedAssemblyOutputDir(target),
};
builder.AddPass(new MemoryEncryptionPass());
builder.AddPass(new ProxyCallPass());
builder.AddPass(new ExprObfuscationPass());
builder.AddPass(new DataVirtualizationPass());
builder.AddPass(new RenameSymbolPass(settings.ruleFiles.ToList(), settings.mappingFile));
return builder;
}
}
}

19
Editor/ObfuscatorContext.cs
View File

@ -1,5 +1,4 @@
using dnlib.DotNet;
using Obfuz.Rename;
using Obfuz.Rename;
using System;
using System.Collections.Generic;
using System.Linq;
@ -8,14 +7,6 @@ using System.Threading.Tasks;
namespace Obfuz
{
public class ObfuzAssemblyInfo
{
public string name;
public ModuleDefMD module;
public List<ObfuzAssemblyInfo> referenceMeAssemblies;
}
public class ObfuscatorContext
{
@ -23,10 +14,10 @@ namespace Obfuz
public List<ObfuzAssemblyInfo> assemblies;
public List<string> obfuscationAssemblyNames;
public List<string> obfuscationRuleFiles;
public string mappingXmlPath;
public List<string> toObfuscatedAssemblyNames;
public string outputDir;
public List<string> notObfuscatedAssemblyNamesReferencingObfuscated;
public string obfuscatedAssemblyOutputDir;
}
}

14
Editor/ObfuzAssemblyInfo.cs Normal file
View File

@ -0,0 +1,14 @@
using dnlib.DotNet;
using System.Collections.Generic;
namespace Obfuz
{
public class ObfuzAssemblyInfo
{
public string name;
public ModuleDefMD module;
public List<ObfuzAssemblyInfo> referenceMeAssemblies;
}
}

7
Editor/Rename/RenameSymbolPass.cs
View File

@ -10,9 +10,14 @@ namespace Obfuz.Rename
{
private SymbolRename _symbolRename;
public RenameSymbolPass(List<string> obfuscationRuleFiles, string mappingXmlPath)
{
_symbolRename = new SymbolRename(mappingXmlPath, obfuscationRuleFiles);
}
public override void Start(ObfuscatorContext ctx)
{
_symbolRename = new SymbolRename(ctx);
_symbolRename.Init(ctx);
}
public override void Stop(ObfuscatorContext ctx)

33
Editor/Rename/SymbolRename.cs
View File

@ -18,16 +18,18 @@ namespace Obfuz
public class SymbolRename
{
private readonly List<string> _obfuscationRuleFiles;
private readonly string _mappingXmlPath;
private readonly AssemblyCache _assemblyCache;
private readonly List<ObfuzAssemblyInfo> _obfuzAssemblies;
private readonly HashSet<ModuleDef> _obfuscatedModules = new HashSet<ModuleDef>();
private readonly ObfuscateRuleConfig _obfuscateRuleConfig;
private readonly IRenamePolicy _renamePolicy;
private readonly INameMaker _nameMaker;
private AssemblyCache _assemblyCache;
private List<ObfuzAssemblyInfo> _obfuzAssemblies;
private HashSet<ModuleDef> _obfuscatedModules = new HashSet<ModuleDef>();
private ObfuscateRuleConfig _obfuscateRuleConfig;
private IRenamePolicy _renamePolicy;
private INameMaker _nameMaker;
private readonly Dictionary<ModuleDef, List<CustomAttributeInfo>> _customAttributeArgumentsWithTypeByMods = new Dictionary<ModuleDef, List<CustomAttributeInfo>>();
private readonly RenameRecordMap _renameRecordMap;
private readonly VirtualMethodGroupCalculator _virtualMethodGroupCalculator = new VirtualMethodGroupCalculator();
private readonly VirtualMethodGroupCalculator _virtualMethodGroupCalculator;
class CustomAttributeInfo
{
@ -37,13 +39,20 @@ namespace Obfuz
public List<CANamedArgument> namedArguments;
}
public SymbolRename(ObfuscatorContext ctx)
public SymbolRename(string mappingXmlPath, List<string> obfuscationRuleFiles)
{
_mappingXmlPath = mappingXmlPath;
_obfuscationRuleFiles = obfuscationRuleFiles;
_renameRecordMap = new RenameRecordMap(mappingXmlPath);
_virtualMethodGroupCalculator = new VirtualMethodGroupCalculator();
}
public void Init(ObfuscatorContext ctx)
{
_mappingXmlPath = ctx.mappingXmlPath;
_assemblyCache = ctx.assemblyCache;
_obfuzAssemblies = ctx.assemblies;
_obfuscateRuleConfig = new ObfuscateRuleConfig(ctx.obfuscationAssemblyNames);
_obfuscateRuleConfig.LoadXmls(ctx.obfuscationRuleFiles);
_obfuscateRuleConfig = new ObfuscateRuleConfig(ctx.toObfuscatedAssemblyNames);
_obfuscateRuleConfig.LoadXmls(_obfuscationRuleFiles);
_renamePolicy = new CacheRenamePolicy(new CombineRenamePolicy(new SystemRenamePolicy(), new UnityRenamePolicy(), _obfuscateRuleConfig));
_nameMaker = NameMakerFactory.CreateNameMakerBaseASCIICharSet();
@ -52,8 +61,6 @@ namespace Obfuz
_obfuscatedModules.Add(mod.module);
}
BuildCustomAttributeArguments();
_renameRecordMap = new RenameRecordMap(ctx.mappingXmlPath);
}
private void CollectCArgumentWithTypeOf(IHasCustomAttribute meta, List<CustomAttributeInfo> customAttributes)

9
Editor/Settings/ObfuzSettingProvider.cs
View File

@ -29,7 +29,8 @@ namespace Obfuz
private SerializedObject _serializedObject;
private SerializedProperty _enable;
private SerializedProperty _obfuscationAssemblyNames;
private SerializedProperty _toObfuscatedAssemblyNames;
private SerializedProperty _notObfuscatedAssemblyNamesReferencingObfuscated;
private SerializedProperty _mappingFile;
private SerializedProperty _ruleFiles;
private SerializedProperty _extraAssemblySearchDirs;
@ -50,7 +51,8 @@ namespace Obfuz
_serializedObject?.Dispose();
_serializedObject = new SerializedObject(setting);
_enable = _serializedObject.FindProperty("enable");
_obfuscationAssemblyNames = _serializedObject.FindProperty("obfuscationAssemblyNames");
_toObfuscatedAssemblyNames = _serializedObject.FindProperty("toObfuscatedAssemblyNames");
_notObfuscatedAssemblyNamesReferencingObfuscated = _serializedObject.FindProperty("notObfuscatedAssemblyNamesReferencingObfuscated");
_mappingFile = _serializedObject.FindProperty("mappingFile");
_ruleFiles = _serializedObject.FindProperty("ruleFiles");
_extraAssemblySearchDirs = _serializedObject.FindProperty("extraAssemblySearchDirs");
@ -74,7 +76,8 @@ namespace Obfuz
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(_enable);
EditorGUILayout.PropertyField(_obfuscationAssemblyNames);
EditorGUILayout.PropertyField(_toObfuscatedAssemblyNames);
EditorGUILayout.PropertyField(_notObfuscatedAssemblyNamesReferencingObfuscated);
EditorGUILayout.PropertyField(_mappingFile);
EditorGUILayout.PropertyField(_ruleFiles);
EditorGUILayout.PropertyField(_extraAssemblySearchDirs);

7
Editor/Settings/ObfuzSettings.cs
View File

@ -13,8 +13,11 @@ namespace Obfuz
[Tooltip("enable Obfuz")]
public bool enable = true;
[Tooltip("obfuscation assembly names")]
public string[] obfuscationAssemblyNames;
[Tooltip("name of assemblies to obfuscated")]
public string[] toObfuscatedAssemblyNames;
[Tooltip("name of assemblies not obfuscated but reference assemblies to obfuscated ")]
public string[] notObfuscatedAssemblyNamesReferencingObfuscated;
[Tooltip("path of mapping.xml")]
public string mappingFile = "Assets/Obfuz/mapping.xml";