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

支持动态和静态secret

backup
walon 2025-05-16 11:33:03 +08:00
parent a171592172
commit 0efdd5b213
14 changed files with 224 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Editor/Data/ConstFieldAllocator.cs
View File

@ -18,10 +18,12 @@ namespace Obfuz.Data
public class ModuleConstFieldAllocator : IGroupByModuleEntity public class ModuleConstFieldAllocator : IGroupByModuleEntity
{ {
private ModuleDef _module; private ModuleDef _module;
private readonly RandomCreator _randomCreator; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IEncryptor _encryptor;
private readonly RvaDataAllocator _rvaDataAllocator; private readonly RvaDataAllocator _rvaDataAllocator;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
private EncryptionScopeInfo _encryptionScope;
private RandomCreator _randomCreator;
private IEncryptor _encryptor;
private TypeDef _holderTypeDef; private TypeDef _holderTypeDef;
@ -60,10 +62,9 @@ namespace Obfuz.Data
private bool _done; private bool _done;
public ModuleConstFieldAllocator(IEncryptor encryptor, RandomCreator randomCreator, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager) public ModuleConstFieldAllocator(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
{ {
_encryptor = encryptor; _encryptionScopeProvider = encryptionScopeProvider;
_randomCreator = randomCreator;
_rvaDataAllocator = rvaDataAllocator; _rvaDataAllocator = rvaDataAllocator;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
} }
@ -71,6 +72,9 @@ namespace Obfuz.Data
public void Init(ModuleDef mod) public void Init(ModuleDef mod)
{ {
_module = mod; _module = mod;
_encryptionScope = _encryptionScopeProvider.GetScope(mod);
_randomCreator = _encryptionScope.localRandomCreator;
_encryptor = _encryptionScope.encryptor;
} }
const int maxFieldCount = 1000; const int maxFieldCount = 1000;
@ -283,22 +287,20 @@ namespace Obfuz.Data
public class ConstFieldAllocator public class ConstFieldAllocator
{ {
private readonly IEncryptor _encryptor; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly RandomCreator _randomCreator;
private readonly RvaDataAllocator _rvaDataAllocator; private readonly RvaDataAllocator _rvaDataAllocator;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
public ConstFieldAllocator(IEncryptor encryptor, RandomCreator randomCreator, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager) public ConstFieldAllocator(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
{ {
_encryptor = encryptor; _encryptionScopeProvider = encryptionScopeProvider;
_randomCreator = randomCreator;
_rvaDataAllocator = rvaDataAllocator; _rvaDataAllocator = rvaDataAllocator;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
} }
private ModuleConstFieldAllocator GetModuleAllocator(ModuleDef mod) private ModuleConstFieldAllocator GetModuleAllocator(ModuleDef mod)
{ {
return _moduleEntityManager.GetEntity<ModuleConstFieldAllocator>(mod, () => new ModuleConstFieldAllocator(_encryptor, _randomCreator, _rvaDataAllocator, _moduleEntityManager)); return _moduleEntityManager.GetEntity<ModuleConstFieldAllocator>(mod, () => new ModuleConstFieldAllocator(_encryptionScopeProvider, _rvaDataAllocator, _moduleEntityManager));
} }
public FieldDef Allocate(ModuleDef mod, int value) public FieldDef Allocate(ModuleDef mod, int value)

26
Editor/Data/RvaDataAllocator.cs
View File

@ -31,10 +31,12 @@ namespace Obfuz.Data
const int maxRvaDataSize = 0x1000; const int maxRvaDataSize = 0x1000;
private ModuleDef _module; private ModuleDef _module;
private readonly IRandom _random; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IEncryptor _encryptor;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
private EncryptionScopeInfo _encryptionScope;
private IRandom _random;
class RvaField class RvaField
{ {
public FieldDef holderDataField; public FieldDef holderDataField;
@ -71,16 +73,17 @@ namespace Obfuz.Data
private readonly Dictionary<int, TypeDef> _dataHolderTypeBySizes = new Dictionary<int, TypeDef>(); private readonly Dictionary<int, TypeDef> _dataHolderTypeBySizes = new Dictionary<int, TypeDef>();
private bool _done; private bool _done;
public ModuleRvaDataAllocator(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager) public ModuleRvaDataAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager)
{ {
_random = random; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
} }
public override void Init(ModuleDef mod) public override void Init(ModuleDef mod)
{ {
_module = mod; _module = mod;
_encryptionScope = _encryptionScopeProvider.GetScope(mod);
_random = _encryptionScope.localRandomCreator(HashUtil.ComputeHash(mod.Name));
} }
private (FieldDef, FieldDef) CreateDataHolderRvaField(TypeDef dataHolderType) private (FieldDef, FieldDef) CreateDataHolderRvaField(TypeDef dataHolderType)
@ -277,7 +280,7 @@ namespace Obfuz.Data
field.FillPaddingToEnd(); field.FillPaddingToEnd();
} }
byte[] data = field.bytes.ToArray(); byte[] data = field.bytes.ToArray();
_encryptor.EncryptBlock(data, field.encryptionOps, field.salt); _encryptionScope.encryptor.EncryptBlock(data, field.encryptionOps, field.salt);
field.holderDataField.InitialValue = data; field.holderDataField.InitialValue = data;
} }
} }
@ -296,21 +299,18 @@ namespace Obfuz.Data
public class RvaDataAllocator public class RvaDataAllocator
{ {
private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IRandom _random;
private readonly IEncryptor _encryptor;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
public RvaDataAllocator(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager) public RvaDataAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager)
{ {
_random = random; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
} }
private ModuleRvaDataAllocator GetModuleRvaDataAllocator(ModuleDef mod) private ModuleRvaDataAllocator GetModuleRvaDataAllocator(ModuleDef mod)
{ {
return _moduleEntityManager.GetEntity<ModuleRvaDataAllocator>(mod, () => new ModuleRvaDataAllocator(_random, _encryptor, _moduleEntityManager)); return _moduleEntityManager.GetEntity<ModuleRvaDataAllocator>(mod, () => new ModuleRvaDataAllocator(_encryptionScopeProvider, _moduleEntityManager));
} }
public RvaData Allocate(ModuleDef mod, int value) public RvaData Allocate(ModuleDef mod, int value)

4
Editor/ObfusPasses/CallObfus/CallObfusPass.cs
View File

@ -17,7 +17,6 @@ namespace Obfuz.ObfusPasses.CallObfus
{ {
private readonly List<string> _configFiles; private readonly List<string> _configFiles;
private readonly int _obfuscationLevel; private readonly int _obfuscationLevel;
private IEncryptor _encryptor;
private IObfuscator _dynamicProxyObfuscator; private IObfuscator _dynamicProxyObfuscator;
private IObfuscationPolicy _dynamicProxyPolicy; private IObfuscationPolicy _dynamicProxyPolicy;
@ -37,8 +36,7 @@ namespace Obfuz.ObfusPasses.CallObfus
public override void Start() public override void Start()
{ {
var ctx = ObfuscationPassContext.Current; var ctx = ObfuscationPassContext.Current;
_encryptor = ctx.encryptor; _dynamicProxyObfuscator = new DefaultCallProxyObfuscator(ctx.encryptionScopeProvider, ctx.constFieldAllocator, ctx.moduleEntityManager, _obfuscationLevel);
_dynamicProxyObfuscator = new DefaultCallProxyObfuscator(ctx.localRandomCreator, _encryptor, ctx.constFieldAllocator, ctx.moduleEntityManager, _obfuscationLevel);
_dynamicProxyPolicy = new ConfigurableObfuscationPolicy(ctx.toObfuscatedAssemblyNames, _configFiles); _dynamicProxyPolicy = new ConfigurableObfuscationPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
} }

27
Editor/ObfusPasses/CallObfus/CallProxyAllocator.cs
View File

@ -34,9 +34,10 @@ namespace Obfuz.ObfusPasses.CallObfus
class ModuleCallProxyAllocator : IGroupByModuleEntity class ModuleCallProxyAllocator : IGroupByModuleEntity
{ {
private ModuleDef _module; private ModuleDef _module;
private readonly RandomCreator _randomCreator; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IEncryptor _encryptor;
private readonly int _encryptionLevel; private readonly int _encryptionLevel;
private EncryptionScopeInfo _encryptionScope;
private bool _done; private bool _done;
class MethodKey : IEquatable<MethodKey> class MethodKey : IEquatable<MethodKey>
@ -95,16 +96,16 @@ namespace Obfuz.ObfusPasses.CallObfus
private TypeDef _proxyTypeDef; private TypeDef _proxyTypeDef;
public ModuleCallProxyAllocator(RandomCreator randomCreator, IEncryptor encryptor, int encryptionLevel) public ModuleCallProxyAllocator(EncryptionScopeProvider encryptionScopeProvider, int encryptionLevel)
{ {
_randomCreator = randomCreator; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_encryptionLevel = encryptionLevel; _encryptionLevel = encryptionLevel;
} }
public void Init(ModuleDef mod) public void Init(ModuleDef mod)
{ {
_module = mod; _module = mod;
_encryptionScope = _encryptionScopeProvider.GetScope(mod);
} }
private TypeDef CreateProxyTypeDef() private TypeDef CreateProxyTypeDef()
@ -160,7 +161,7 @@ namespace Obfuz.ObfusPasses.CallObfus
private int GenerateEncryptOps(IRandom random) private int GenerateEncryptOps(IRandom random)
{ {
return EncryptionUtil.GenerateEncryptionOpCodes(random, _encryptor, _encryptionLevel); return EncryptionUtil.GenerateEncryptionOpCodes(random, _encryptionScope.encryptor, _encryptionLevel);
} }
private DispatchMethodInfo GetDispatchMethod(IMethod method) private DispatchMethodInfo GetDispatchMethod(IMethod method)
@ -185,7 +186,7 @@ namespace Obfuz.ObfusPasses.CallObfus
private IRandom CreateRandomForMethod(IMethod method, bool callVir) private IRandom CreateRandomForMethod(IMethod method, bool callVir)
{ {
int seed = MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method); int seed = MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method);
return _randomCreator(seed); return _encryptionScope.localRandomCreator(seed);
} }
public ProxyCallMethodData Allocate(IMethod method, bool callVir) public ProxyCallMethodData Allocate(IMethod method, bool callVir)
@ -203,7 +204,7 @@ namespace Obfuz.ObfusPasses.CallObfus
IRandom localRandom = CreateRandomForMethod(method, callVir); IRandom localRandom = CreateRandomForMethod(method, callVir);
int encryptOps = GenerateEncryptOps(localRandom); int encryptOps = GenerateEncryptOps(localRandom);
int salt = GenerateSalt(localRandom); int salt = GenerateSalt(localRandom);
int encryptedIndex = _encryptor.Encrypt(index, encryptOps, salt); int encryptedIndex = _encryptionScope.encryptor.Encrypt(index, encryptOps, salt);
proxyInfo = new MethodProxyInfo() proxyInfo = new MethodProxyInfo()
{ {
proxyMethod = methodDispatcher.methodDef, proxyMethod = methodDispatcher.methodDef,
@ -259,22 +260,20 @@ namespace Obfuz.ObfusPasses.CallObfus
public class CallProxyAllocator public class CallProxyAllocator
{ {
private readonly RandomCreator _randomCreator; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IEncryptor _encryptor;
private GroupByModuleEntityManager _moduleEntityManager; private GroupByModuleEntityManager _moduleEntityManager;
private readonly int _encryptionLevel; private readonly int _encryptionLevel;
public CallProxyAllocator(RandomCreator randomCreator, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel) public CallProxyAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
{ {
_randomCreator = randomCreator; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
_encryptionLevel = encryptionLevel; _encryptionLevel = encryptionLevel;
} }
private ModuleCallProxyAllocator GetModuleAllocator(ModuleDef mod) private ModuleCallProxyAllocator GetModuleAllocator(ModuleDef mod)
{ {
return _moduleEntityManager.GetEntity<ModuleCallProxyAllocator>(mod, () => new ModuleCallProxyAllocator(_randomCreator, _encryptor, _encryptionLevel)); return _moduleEntityManager.GetEntity<ModuleCallProxyAllocator>(mod, () => new ModuleCallProxyAllocator(_encryptionScopeProvider, _encryptionLevel));
} }
public ProxyCallMethodData Allocate(ModuleDef mod, IMethod method, bool callVir) public ProxyCallMethodData Allocate(ModuleDef mod, IMethod method, bool callVir)

8
Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs
View File

@ -10,17 +10,17 @@ namespace Obfuz.ObfusPasses.CallObfus
{ {
public class DefaultCallProxyObfuscator : ObfuscatorBase public class DefaultCallProxyObfuscator : ObfuscatorBase
{ {
private readonly IEncryptor _encryptor; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly ConstFieldAllocator _constFieldAllocator; private readonly ConstFieldAllocator _constFieldAllocator;
private readonly CallProxyAllocator _proxyCallAllocator; private readonly CallProxyAllocator _proxyCallAllocator;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
public DefaultCallProxyObfuscator(RandomCreator randomCreator, IEncryptor encryptor, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel) public DefaultCallProxyObfuscator(EncryptionScopeProvider encryptionScopeProvider, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
{ {
_encryptor = encryptor; _encryptionScopeProvider = encryptionScopeProvider;
_constFieldAllocator = constFieldAllocator; _constFieldAllocator = constFieldAllocator;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
_proxyCallAllocator = new CallProxyAllocator(randomCreator, _encryptor, moduleEntityManager, encryptionLevel); _proxyCallAllocator = new CallProxyAllocator(encryptionScopeProvider, moduleEntityManager, encryptionLevel);
} }
public override void Done() public override void Done()

2
Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
View File

@ -31,7 +31,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
{ {
var ctx = ObfuscationPassContext.Current; var ctx = ObfuscationPassContext.Current;
_dataObfuscatorPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles); _dataObfuscatorPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
_dataObfuscator = new DefaultConstEncryptor(ctx.localRandomCreator, ctx.encryptor, ctx.rvaDataAllocator, ctx.constFieldAllocator, ctx.moduleEntityManager, _encryptionLevel); _dataObfuscator = new DefaultConstEncryptor(ctx.encryptionScopeProvider, ctx.rvaDataAllocator, ctx.constFieldAllocator, ctx.moduleEntityManager, _encryptionLevel);
} }
public override void Stop() public override void Stop()

51
Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
View File

@ -12,31 +12,29 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
{ {
public class DefaultConstEncryptor : IConstEncryptor public class DefaultConstEncryptor : IConstEncryptor
{ {
private readonly RandomCreator _randomCreator; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly RvaDataAllocator _rvaDataAllocator; private readonly RvaDataAllocator _rvaDataAllocator;
private readonly ConstFieldAllocator _constFieldAllocator; private readonly ConstFieldAllocator _constFieldAllocator;
private readonly IEncryptor _encryptor;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
private readonly int _encryptionLevel; private readonly int _encryptionLevel;
public DefaultConstEncryptor(RandomCreator randomCreator, IEncryptor encryptor, RvaDataAllocator rvaDataAllocator, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel) public DefaultConstEncryptor(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
{ {
_randomCreator = randomCreator; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_rvaDataAllocator = rvaDataAllocator; _rvaDataAllocator = rvaDataAllocator;
_constFieldAllocator = constFieldAllocator; _constFieldAllocator = constFieldAllocator;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
_encryptionLevel = encryptionLevel; _encryptionLevel = encryptionLevel;
} }
private IRandom CreateRandomForValue(int value) private IRandom CreateRandomForValue(EncryptionScopeInfo encryptionScope, int value)
{ {
return _randomCreator(value); return encryptionScope.localRandomCreator(value);
} }
private int GenerateEncryptionOperations(IRandom random) private int GenerateEncryptionOperations(EncryptionScopeInfo encryptionScope, IRandom random)
{ {
return EncryptionUtil.GenerateEncryptionOpCodes(random, _encryptor, _encryptionLevel); return EncryptionUtil.GenerateEncryptionOpCodes(random, encryptionScope.encryptor, _encryptionLevel);
} }
public int GenerateSalt(IRandom random) public int GenerateSalt(IRandom random)
@ -58,10 +56,11 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
return; return;
} }
IRandom random = CreateRandomForValue(value.GetHashCode()); EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
int ops = GenerateEncryptionOperations(random); IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
int ops = GenerateEncryptionOperations(encryptionScope, random);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
int encryptedValue = _encryptor.Encrypt(value, ops, salt); int encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue); RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
DefaultMetadataImporter importer = GetModuleMetadataImporter(method); DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
@ -81,10 +80,11 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
return; return;
} }
IRandom random = CreateRandomForValue(value.GetHashCode()); EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
int ops = GenerateEncryptionOperations(random); IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
int ops = GenerateEncryptionOperations(encryptionScope, random);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
long encryptedValue = _encryptor.Encrypt(value, ops, salt); long encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue); RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
DefaultMetadataImporter importer = GetModuleMetadataImporter(method); DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
@ -104,10 +104,11 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
return; return;
} }
IRandom random = CreateRandomForValue(value.GetHashCode()); EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
int ops = GenerateEncryptionOperations(random); IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
int ops = GenerateEncryptionOperations(encryptionScope, random);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
float encryptedValue = _encryptor.Encrypt(value, ops, salt); float encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue); RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
DefaultMetadataImporter importer = GetModuleMetadataImporter(method); DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
@ -127,10 +128,11 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
return; return;
} }
IRandom random = CreateRandomForValue(value.GetHashCode()); EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
int ops = GenerateEncryptionOperations(random); IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
int ops = GenerateEncryptionOperations(encryptionScope, random);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
double encryptedValue = _encryptor.Encrypt(value, ops, salt); double encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue); RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
DefaultMetadataImporter importer = GetModuleMetadataImporter(method); DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
@ -176,11 +178,12 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
return; return;
} }
IRandom random = CreateRandomForValue(HashUtil.ComputeHash(value)); EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
int ops = GenerateEncryptionOperations(random); IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
int ops = GenerateEncryptionOperations(encryptionScope, random);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
int stringByteLength = Encoding.UTF8.GetByteCount(value); int stringByteLength = Encoding.UTF8.GetByteCount(value);
byte[] encryptedValue = _encryptor.Encrypt(value, ops, salt); byte[] encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
Assert.IsTrue(encryptedValue.Length % 4 == 0); Assert.IsTrue(encryptedValue.Length % 4 == 0);
RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue); RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);

30
Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
View File

@ -12,15 +12,13 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
{ {
public class DefaultFieldEncryptor : FieldEncryptorBase public class DefaultFieldEncryptor : FieldEncryptorBase
{ {
private readonly RandomCreator _randomCreator; private readonly EncryptionScopeProvider _encryptionScopeProvider;
private readonly IEncryptor _encryptor;
private readonly GroupByModuleEntityManager _moduleEntityManager; private readonly GroupByModuleEntityManager _moduleEntityManager;
private readonly int _encryptionLevel; private readonly int _encryptionLevel;
public DefaultFieldEncryptor(RandomCreator randomCreator, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel) public DefaultFieldEncryptor(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
{ {
_randomCreator = randomCreator; _encryptionScopeProvider = encryptionScopeProvider;
_encryptor = encryptor;
_moduleEntityManager = moduleEntityManager; _moduleEntityManager = moduleEntityManager;
_encryptionLevel = encryptionLevel; _encryptionLevel = encryptionLevel;
} }
@ -41,32 +39,32 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
private readonly Dictionary<FieldDef, FieldEncryptInfo> _fieldEncryptInfoCache = new Dictionary<FieldDef, FieldEncryptInfo>(); private readonly Dictionary<FieldDef, FieldEncryptInfo> _fieldEncryptInfoCache = new Dictionary<FieldDef, FieldEncryptInfo>();
private long CalcXorValueForZero(ElementType type, int encryptOps, int salt) private long CalcXorValueForZero(IEncryptor encryptor, ElementType type, int encryptOps, int salt)
{ {
switch (type) switch (type)
{ {
case ElementType.I4: case ElementType.I4:
case ElementType.U4: case ElementType.U4:
case ElementType.R4: case ElementType.R4:
return _encryptor.Encrypt(0, encryptOps, salt); return encryptor.Encrypt(0, encryptOps, salt);
case ElementType.I8: case ElementType.I8:
case ElementType.U8: case ElementType.U8:
case ElementType.R8: case ElementType.R8:
return _encryptor.Encrypt(0L, encryptOps, salt); return encryptor.Encrypt(0L, encryptOps, salt);
default: default:
throw new NotSupportedException($"Unsupported field type: {type} for encryption"); throw new NotSupportedException($"Unsupported field type: {type} for encryption");
} }
} }
private IRandom CreateRandomForField(FieldDef field) private IRandom CreateRandomForField(RandomCreator randomCreator, FieldDef field)
{ {
return _randomCreator(FieldEqualityComparer.CompareDeclaringTypes.GetHashCode(field)); return randomCreator(FieldEqualityComparer.CompareDeclaringTypes.GetHashCode(field));
} }
private int GenerateEncryptionOperations(IRandom random) private int GenerateEncryptionOperations(IRandom random, IEncryptor encryptor)
{ {
return EncryptionUtil.GenerateEncryptionOpCodes(random, _encryptor, _encryptionLevel); return EncryptionUtil.GenerateEncryptionOpCodes(random, encryptor, _encryptionLevel);
} }
public int GenerateSalt(IRandom random) public int GenerateSalt(IRandom random)
@ -80,12 +78,14 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
{ {
return info; return info;
} }
EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(field.Module);
IRandom random = CreateRandomForField(field); IRandom random = CreateRandomForField(encryptionScope.localRandomCreator, field);
int encryptOps = GenerateEncryptionOperations(random); IEncryptor encryptor = encryptionScope.encryptor;
int encryptOps = GenerateEncryptionOperations(random, encryptor);
int salt = GenerateSalt(random); int salt = GenerateSalt(random);
ElementType fieldType = field.FieldSig.Type.RemovePinnedAndModifiers().ElementType; ElementType fieldType = field.FieldSig.Type.RemovePinnedAndModifiers().ElementType;
long xorValueForZero = CalcXorValueForZero(fieldType, encryptOps, salt); long xorValueForZero = CalcXorValueForZero(encryptor, fieldType, encryptOps, salt);
info = new FieldEncryptInfo info = new FieldEncryptInfo
{ {

2
Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
View File

@ -30,7 +30,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
public override void Start() public override void Start()
{ {
var ctx = ObfuscationPassContext.Current; var ctx = ObfuscationPassContext.Current;
_memoryEncryptor = new DefaultFieldEncryptor(ctx.localRandomCreator, ctx.encryptor, ctx.moduleEntityManager, _encryptionLevel); _memoryEncryptor = new DefaultFieldEncryptor(ctx.encryptionScopeProvider, ctx.moduleEntityManager, _encryptionLevel);
_encryptionPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles); _encryptionPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
} }

47
Editor/ObfuscationPassContext.cs
View File

@ -14,6 +14,48 @@ namespace Obfuz
{ {
public delegate IRandom RandomCreator(int seed); public delegate IRandom RandomCreator(int seed);
public class EncryptionScopeInfo
{
public readonly byte[] byteSecret;
public readonly int[] intSecret;
public readonly IEncryptor encryptor;
public readonly RandomCreator localRandomCreator;
public EncryptionScopeInfo(byte[] byteSecret, int[] intSecret, IEncryptor encryptor, RandomCreator localRandomCreator)
{
this.byteSecret = byteSecret;
this.intSecret = intSecret;
this.encryptor = encryptor;
this.localRandomCreator = localRandomCreator;
}
}
public class EncryptionScopeProvider
{
private readonly EncryptionScopeInfo _defaultStaticScope;
private readonly EncryptionScopeInfo _defaultDynamicScope;
private readonly HashSet<string> _dynamicSecretAssemblyNames;
public EncryptionScopeProvider(EncryptionScopeInfo defaultStaticScope, EncryptionScopeInfo defaultDynamicScope, HashSet<string> dynamicSecretAssemblyNames)
{
_defaultStaticScope = defaultStaticScope;
_defaultDynamicScope = defaultDynamicScope;
_dynamicSecretAssemblyNames = dynamicSecretAssemblyNames;
}
public EncryptionScopeInfo GetScope(ModuleDef module)
{
if (_dynamicSecretAssemblyNames.Contains(module.Assembly.Name))
{
return _defaultDynamicScope;
}
else
{
return _defaultStaticScope;
}
}
}
public class ObfuscationPassContext public class ObfuscationPassContext
{ {
public static ObfuscationPassContext Current { get; set; } public static ObfuscationPassContext Current { get; set; }
@ -31,10 +73,7 @@ namespace Obfuz
public string obfuscatedAssemblyOutputDir; public string obfuscatedAssemblyOutputDir;
public IRandom globalRandom; public EncryptionScopeProvider encryptionScopeProvider;
public RandomCreator localRandomCreator;
public IEncryptor encryptor;
public ConstFieldAllocator constFieldAllocator; public ConstFieldAllocator constFieldAllocator;
public RvaDataAllocator rvaDataAllocator; public RvaDataAllocator rvaDataAllocator;
public NotObfuscatedMethodWhiteList whiteList; public NotObfuscatedMethodWhiteList whiteList;

54
Editor/Obfuscator.cs
View File

@ -31,8 +31,13 @@ namespace Obfuz
private readonly Pipeline _pipeline1 = new Pipeline(); private readonly Pipeline _pipeline1 = new Pipeline();
private readonly Pipeline _pipeline2 = new Pipeline(); private readonly Pipeline _pipeline2 = new Pipeline();
private readonly byte[] _byteSecret;
private readonly int[] _intSecret; private readonly byte[] _defaultStaticByteSecret;
private readonly int[] _defaultStaticIntSecret;
private readonly byte[] _defaultDynamicByteSecret;
private readonly int[] _defaultDynamicIntSecret;
private readonly HashSet<string> _dynamicSecretAssemblyNames;
private readonly int _randomSeed; private readonly int _randomSeed;
private readonly string _encryptionVmGenerationSecret; private readonly string _encryptionVmGenerationSecret;
private readonly int _encryptionVmOpCodeCount; private readonly int _encryptionVmOpCodeCount;
@ -42,9 +47,15 @@ namespace Obfuz
public Obfuscator(ObfuscatorBuilder builder) public Obfuscator(ObfuscatorBuilder builder)
{ {
_byteSecret = KeyGenerator.GenerateKey(builder.Secret, VirtualMachine.SecretKeyLength); _defaultStaticByteSecret = KeyGenerator.GenerateKey(builder.DefaultStaticSecret, VirtualMachine.SecretKeyLength);
_intSecret = KeyGenerator.ConvertToIntKey(_byteSecret); _defaultStaticIntSecret = KeyGenerator.ConvertToIntKey(_defaultStaticByteSecret);
SaveKey(_byteSecret, builder.SecretOutputPath); SaveKey(_defaultStaticByteSecret, builder.DefaultStaticSecretOutputPath);
_defaultDynamicByteSecret = KeyGenerator.GenerateKey(builder.DefaultDynamicSecret, VirtualMachine.SecretKeyLength);
_defaultDynamicIntSecret = KeyGenerator.ConvertToIntKey(_defaultDynamicByteSecret);
SaveKey(_defaultDynamicByteSecret, builder.DefaultDynamicSecretOutputPath);
_dynamicSecretAssemblyNames = new HashSet<string>(builder.DynamicSecretAssemblyNames);
_randomSeed = builder.RandomSeed; _randomSeed = builder.RandomSeed;
_encryptionVmGenerationSecret = builder.EncryptionVmGenerationSecretKey; _encryptionVmGenerationSecret = builder.EncryptionVmGenerationSecretKey;
_encryptionVmOpCodeCount = builder.EncryptionVmOpCodeCount; _encryptionVmOpCodeCount = builder.EncryptionVmOpCodeCount;
@ -98,7 +109,7 @@ namespace Obfuz
OnPostObfuscation(pipeline); OnPostObfuscation(pipeline);
} }
private IEncryptor CreateEncryptionVirtualMachine() private IEncryptor CreateEncryptionVirtualMachine(byte[] secret)
{ {
var vmCreator = new VirtualMachineCreator(_encryptionVmGenerationSecret); var vmCreator = new VirtualMachineCreator(_encryptionVmGenerationSecret);
var vm = vmCreator.CreateVirtualMachine(_encryptionVmOpCodeCount); var vm = vmCreator.CreateVirtualMachine(_encryptionVmOpCodeCount);
@ -112,7 +123,7 @@ namespace Obfuz
{ {
throw new Exception($"EncryptionVm CodeFile:`{_encryptionVmCodeFile}` not match with encryptionVM settings! Please run `Obfuz/GenerateVm` to update it!"); throw new Exception($"EncryptionVm CodeFile:`{_encryptionVmCodeFile}` not match with encryptionVM settings! Please run `Obfuz/GenerateVm` to update it!");
} }
var vms = new VirtualMachineSimulator(vm, _byteSecret); var vms = new VirtualMachineSimulator(vm, secret);
var generatedVmTypes = AppDomain.CurrentDomain.GetAssemblies() var generatedVmTypes = AppDomain.CurrentDomain.GetAssemblies()
.Select(assembly => assembly.GetType("Obfuz.EncryptionVM.GeneratedEncryptionVirtualMachine")) .Select(assembly => assembly.GetType("Obfuz.EncryptionVM.GeneratedEncryptionVirtualMachine"))
@ -127,7 +138,7 @@ namespace Obfuz
throw new Exception($"class Obfuz.EncryptionVM.GeneratedEncryptionVirtualMachine found in multiple assemblies! Please retain only one!"); throw new Exception($"class Obfuz.EncryptionVM.GeneratedEncryptionVirtualMachine found in multiple assemblies! Please retain only one!");
} }
var gvmInstance = (IEncryptor)Activator.CreateInstance(generatedVmTypes[0], new object[] { _byteSecret } ); var gvmInstance = (IEncryptor)Activator.CreateInstance(generatedVmTypes[0], new object[] { secret } );
VerifyVm(vm, vms, gvmInstance); VerifyVm(vm, vms, gvmInstance);
@ -241,6 +252,20 @@ namespace Obfuz
} }
} }
private EncryptionScopeInfo CreateEncryptionScope(byte[] byteSecret, int[] intSecret)
{
IEncryptor encryption = CreateEncryptionVirtualMachine(byteSecret);
RandomCreator localRandomCreator = (seed) => new RandomWithKey(intSecret, _randomSeed ^ seed);
return new EncryptionScopeInfo(byteSecret, intSecret, encryption, localRandomCreator);
}
private EncryptionScopeProvider CreateEncryptionScopeProvider()
{
var defaultStaticScope = CreateEncryptionScope(_defaultStaticByteSecret, _defaultStaticIntSecret);
var defaultDynamicScope = CreateEncryptionScope(_defaultDynamicByteSecret, _defaultDynamicIntSecret);
return new EncryptionScopeProvider(defaultStaticScope, defaultDynamicScope, _dynamicSecretAssemblyNames);
}
private void OnPreObfuscation(Pipeline pipeline) private void OnPreObfuscation(Pipeline pipeline)
{ {
AssemblyCache assemblyCache = new AssemblyCache(new PathAssemblyResolver(_assemblySearchDirs.ToArray())); AssemblyCache assemblyCache = new AssemblyCache(new PathAssemblyResolver(_assemblySearchDirs.ToArray()));
@ -248,12 +273,10 @@ namespace Obfuz
List<ModuleDef> obfuscatedAndNotObfuscatedModules = new List<ModuleDef>(); List<ModuleDef> obfuscatedAndNotObfuscatedModules = new List<ModuleDef>();
LoadAssemblies(assemblyCache, toObfuscatedModules, obfuscatedAndNotObfuscatedModules); LoadAssemblies(assemblyCache, toObfuscatedModules, obfuscatedAndNotObfuscatedModules);
var random = new RandomWithKey(_intSecret, _randomSeed); EncryptionScopeProvider encryptionScopeProvider = CreateEncryptionScopeProvider();
RandomCreator localRandomCreator = (seed) => new RandomWithKey(_intSecret, _randomSeed ^ seed);
var encryptor = CreateEncryptionVirtualMachine();
var moduleEntityManager = new GroupByModuleEntityManager(); var moduleEntityManager = new GroupByModuleEntityManager();
var rvaDataAllocator = new RvaDataAllocator(random, encryptor, moduleEntityManager); var rvaDataAllocator = new RvaDataAllocator(encryptionScopeProvider, moduleEntityManager);
var constFieldAllocator = new ConstFieldAllocator(encryptor, localRandomCreator, rvaDataAllocator, moduleEntityManager); var constFieldAllocator = new ConstFieldAllocator(encryptionScopeProvider, rvaDataAllocator, moduleEntityManager);
_ctx = new ObfuscationPassContext _ctx = new ObfuscationPassContext
{ {
assemblyCache = assemblyCache, assemblyCache = assemblyCache,
@ -264,9 +287,8 @@ namespace Obfuz
obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir, obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir,
moduleEntityManager = moduleEntityManager, moduleEntityManager = moduleEntityManager,
globalRandom = random, encryptionScopeProvider = encryptionScopeProvider,
localRandomCreator = localRandomCreator,
encryptor = encryptor,
rvaDataAllocator = rvaDataAllocator, rvaDataAllocator = rvaDataAllocator,
constFieldAllocator = constFieldAllocator, constFieldAllocator = constFieldAllocator,
whiteList = new NotObfuscatedMethodWhiteList(), whiteList = new NotObfuscatedMethodWhiteList(),

45
Editor/ObfuscatorBuilder.cs
View File

@ -15,8 +15,12 @@ namespace Obfuz
{ {
public class ObfuscatorBuilder public class ObfuscatorBuilder
{ {
private string _secret; private string _defaultStaticSecret;
private string _secretOutputPath; private string _defaultStaticSecretOutputPath;
private string _defaultDynamicSecret;
private string _defaultDynamicSecretOutputPath;
private List<string> _dynamicSecretAssemblyNames = new List<string>();
private int _randomSeed; private int _randomSeed;
private string _encryptionVmGenerationSecretKey; private string _encryptionVmGenerationSecretKey;
private int _encryptionVmOpCodeCount; private int _encryptionVmOpCodeCount;
@ -32,16 +36,34 @@ namespace Obfuz
private ObfuscationPassType _enabledObfuscationPasses; private ObfuscationPassType _enabledObfuscationPasses;
private List<IObfuscationPass> _obfuscationPasses = new List<IObfuscationPass>(); private List<IObfuscationPass> _obfuscationPasses = new List<IObfuscationPass>();
public string Secret public string DefaultStaticSecret
{ {
get => _secret; get => _defaultStaticSecret;
set => _secret = value; set => _defaultStaticSecret = value;
} }
public string SecretOutputPath public string DefaultStaticSecretOutputPath
{ {
get => _secretOutputPath; get => _defaultStaticSecretOutputPath;
set => _secretOutputPath = value; set => _defaultStaticSecretOutputPath = value;
}
public string DefaultDynamicSecret
{
get => _defaultDynamicSecret;
set => _defaultDynamicSecret = value;
}
public string DefaultDynamicSecretOutputPath
{
get => _defaultDynamicSecretOutputPath;
set => _defaultDynamicSecretOutputPath = value;
}
public List<string> DynamicSecretAssemblyNames
{
get => _dynamicSecretAssemblyNames;
set => _dynamicSecretAssemblyNames = value;
} }
public int RandomSeed public int RandomSeed
@ -151,8 +173,11 @@ namespace Obfuz
: settings.assemblySettings.extraAssemblySearchDirs.ToList(); : settings.assemblySettings.extraAssemblySearchDirs.ToList();
var builder = new ObfuscatorBuilder var builder = new ObfuscatorBuilder
{ {
_secret = settings.secretSettings.secret, _defaultStaticSecret = settings.secretSettings.defaultStaticSecret,
_secretOutputPath = settings.secretSettings.secretOutputPath, _defaultStaticSecretOutputPath = settings.secretSettings.DefaultStaticSecretKeyOutputPath,
_defaultDynamicSecret = settings.secretSettings.defaultDynamicSecret,
_defaultDynamicSecretOutputPath = settings.secretSettings.DefaultDynamicSecretKeyOutputPath,
_dynamicSecretAssemblyNames = settings.secretSettings.dynamicSecretAssemblyNames.ToList(),
_randomSeed = settings.secretSettings.randomSeed, _randomSeed = settings.secretSettings.randomSeed,
_encryptionVmGenerationSecretKey = settings.encryptionVMSettings.codeGenerationSecret, _encryptionVmGenerationSecretKey = settings.encryptionVMSettings.codeGenerationSecret,
_encryptionVmOpCodeCount = settings.encryptionVMSettings.encryptionOpCodeCount, _encryptionVmOpCodeCount = settings.encryptionVMSettings.encryptionOpCodeCount,

18
Editor/Settings/SecretSettings.cs
View File

@ -1,4 +1,5 @@
using System; using System;
using System.IO;
using UnityEngine; using UnityEngine;
namespace Obfuz.Settings namespace Obfuz.Settings
@ -7,13 +8,22 @@ namespace Obfuz.Settings
public class SecretSettings public class SecretSettings
{ {
[Tooltip("secret key")] [Tooltip("default static secret key")]
public string secret = "Code Philosophy"; public string defaultStaticSecret = "Code Philosophy-Static";
[Tooltip("secret key save path")] public string defaultDynamicSecret = "Code Philosophy-Dynamic";
public string secretOutputPath = $"Assets/Obfuz/secret.bytes";
[Tooltip("secret key output directory")]
public string secretOutputDir = $"Assets/Resources/Obfuz";
[Tooltip("random seed")] [Tooltip("random seed")]
public int randomSeed = 0; public int randomSeed = 0;
[Tooltip("name of assemblies those use dynamic secret")]
public string[] dynamicSecretAssemblyNames;
public string DefaultStaticSecretKeyOutputPath => Path.Combine(secretOutputDir, "defaultStaticSecret.bytes");
public string DefaultDynamicSecretKeyOutputPath => Path.Combine(secretOutputDir, "defaultDynamicSecret.bytes");
} }
} }

8
Editor/Unity/ObfuzMenu.cs
View File

@ -28,8 +28,12 @@ namespace Obfuz.Unity
{ {
SecretSettings settings = ObfuzSettings.Instance.secretSettings; SecretSettings settings = ObfuzSettings.Instance.secretSettings;
var secretBytes = KeyGenerator.GenerateKey(settings.secret, VirtualMachine.SecretKeyLength); var staticSecretBytes = KeyGenerator.GenerateKey(settings.defaultStaticSecret, VirtualMachine.SecretKeyLength);
Obfuscator.SaveKey(secretBytes, settings.secretOutputPath); Obfuscator.SaveKey(staticSecretBytes, settings.DefaultStaticSecretKeyOutputPath);
Debug.Log($"Save static secret key to {settings.DefaultStaticSecretKeyOutputPath}");
var dynamicSecretBytes = KeyGenerator.GenerateKey(settings.defaultDynamicSecret, VirtualMachine.SecretKeyLength);
Obfuscator.SaveKey(dynamicSecretBytes, settings.DefaultDynamicSecretKeyOutputPath);
Debug.Log($"Save dynamic secret key to {settings.DefaultDynamicSecretKeyOutputPath}");
} }
[MenuItem("Obfuz/Documents/Quick Start")] [MenuItem("Obfuz/Documents/Quick Start")]