From 6d7c86da32de3cda283ad74f5d30e7b3cf37f555 Mon Sep 17 00:00:00 2001 From: walon Date: Fri, 16 May 2025 12:33:37 +0800 Subject: [PATCH] =?UTF-8?q?-=20=E4=BF=AE=E5=A4=8D=20FieldEncrypt=E5=8A=A0?= =?UTF-8?q?=E5=AF=86=E5=AD=97=E6=AE=B5=E6=9C=AA=E4=BD=BF=E7=94=A8=E5=AD=97?= =?UTF-8?q?=E6=AE=B5=E6=89=80=E5=9C=A8=E7=A8=8B=E5=BA=8F=E9=9B=86=E7=9A=84?= =?UTF-8?q?EncryptionScope=E8=80=8C=E4=BD=BF=E7=94=A8=E8=87=AA=E8=BA=ABEnc?= =?UTF-8?q?yrptionScope=E7=9A=84bug=20-=20=E4=BC=98=E5=8C=96=EF=BC=8C?= =?UTF-8?q?=E8=A7=A3=E5=86=B3=20XorInstruction=E9=87=8A=E5=8A=A00->0?= =?UTF-8?q?=E6=98=A0=E5=B0=84=E5=90=8E=EF=BC=8C=E5=B0=86=E6=89=80=E6=9C=89?= =?UTF-8?q?=E5=80=BC=E6=98=A0=E5=B0=84=E4=B8=BA=E8=87=AA=E8=BA=AB=E7=9A=84?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Editor/Data/ConstFieldAllocator.cs | 2 +- Editor/Data/RvaDataAllocator.cs | 2 +- Editor/Emit/DefaultMetadataImporter.cs | 215 +++++++++++------- Editor/Emit/GroupByModuleEntityManager.cs | 4 +- .../Instructions/AddInstruction.cs | 8 +- .../Instructions/XorInstruction.cs | 8 +- .../CallObfus/DefaultCallProxyObfuscator.cs | 2 +- .../ConstEncrypt/DefaultConstEncryptor.cs | 2 +- .../FieldEncrypt/DefaultFieldEncryptor.cs | 12 +- Editor/ObfuscationPassContext.cs | 5 + Editor/Obfuscator.cs | 16 +- Editor/Unity/ObfuzMenu.cs | 10 +- 12 files changed, 179 insertions(+), 107 deletions(-) diff --git a/Editor/Data/ConstFieldAllocator.cs b/Editor/Data/ConstFieldAllocator.cs index bdcead5..23650f3 100644 --- a/Editor/Data/ConstFieldAllocator.cs +++ b/Editor/Data/ConstFieldAllocator.cs @@ -165,7 +165,7 @@ namespace Obfuz.Data private DefaultMetadataImporter GetModuleMetadataImporter() { - return _moduleEntityManager.GetDefaultModuleMetadataImporter(_module); + return _moduleEntityManager.GetDefaultModuleMetadataImporter(_module, _encryptionScopeProvider); } private void CreateCCtorOfRvaTypeDef(TypeDef type) diff --git a/Editor/Data/RvaDataAllocator.cs b/Editor/Data/RvaDataAllocator.cs index 3ca9e8a..ed8e748 100644 --- a/Editor/Data/RvaDataAllocator.cs +++ b/Editor/Data/RvaDataAllocator.cs @@ -244,7 +244,7 @@ namespace Obfuz.Data cctorMethod.Body = body; var ins = body.Instructions; - DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(mod); + DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(mod, _encryptionScopeProvider); foreach (var field in _rvaFields) { // ldc diff --git a/Editor/Emit/DefaultMetadataImporter.cs b/Editor/Emit/DefaultMetadataImporter.cs index ba71061..8a3c30d 100644 --- a/Editor/Emit/DefaultMetadataImporter.cs +++ b/Editor/Emit/DefaultMetadataImporter.cs @@ -4,77 +4,10 @@ using UnityEngine.Assertions; namespace Obfuz.Emit { - public class DefaultMetadataImporter : GroupByModuleEntityBase + public class EncryptionServiceMetadataImporter { - public DefaultMetadataImporter() { } - - public override void Init(ModuleDef mod) - { - _module = mod; - var constUtilityType = typeof(ConstUtility); - - _castIntAsFloat = mod.Import(constUtilityType.GetMethod("CastIntAsFloat")); - Assert.IsNotNull(_castIntAsFloat, "CastIntAsFloat not found"); - _castLongAsDouble = mod.Import(constUtilityType.GetMethod("CastLongAsDouble")); - Assert.IsNotNull(_castLongAsDouble, "CastLongAsDouble not found"); - _castFloatAsInt = mod.Import(constUtilityType.GetMethod("CastFloatAsInt")); - Assert.IsNotNull(_castFloatAsInt, "CastFloatAsInt not found"); - _castDoubleAsLong = mod.Import(constUtilityType.GetMethod("CastDoubleAsLong")); - Assert.IsNotNull(_castDoubleAsLong, "CastDoubleAsLong not found"); - - _initializeArray = mod.Import(typeof(System.Runtime.CompilerServices.RuntimeHelpers).GetMethod("InitializeArray", new[] { typeof(Array), typeof(RuntimeFieldHandle) })); - Assert.IsNotNull(_initializeArray); - - Type encryptionService = typeof(EncryptionService); - _encryptBlock = mod.Import(encryptionService.GetMethod("EncryptBlock", new[] { typeof(byte[]), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptBlock); - _decryptBlock = mod.Import(encryptionService.GetMethod("DecryptBlock", new[] { typeof(byte[]), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptBlock); - _encryptInt = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptInt); - _decryptInt = mod.Import(encryptionService.GetMethod("Decrypt", new[] { typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptInt); - _encryptLong = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(long), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptLong); - _decryptLong = mod.Import(encryptionService.GetMethod("Decrypt", new[] { typeof(long), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptLong); - _encryptFloat = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(float), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptFloat); - _decryptFloat = mod.Import(encryptionService.GetMethod("Decrypt", new[] { typeof(float), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFloat); - _encryptDouble = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(double), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptDouble); - _decryptDouble = mod.Import(encryptionService.GetMethod("Decrypt", new[] { typeof(double), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptDouble); - _encryptString = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(string), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptString); - _decryptString = mod.Import(encryptionService.GetMethod("DecryptString", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptString); - _encryptBytes = mod.Import(encryptionService.GetMethod("Encrypt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_encryptBytes); - _decryptBytes = mod.Import(encryptionService.GetMethod("Decrypt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptBytes); - - _decryptFromRvaInt = mod.Import(encryptionService.GetMethod("DecryptFromRvaInt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaInt); - _decryptFromRvaLong = mod.Import(encryptionService.GetMethod("DecryptFromRvaLong", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaLong); - _decryptFromRvaFloat = mod.Import(encryptionService.GetMethod("DecryptFromRvaFloat", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaFloat); - _decryptFromRvaDouble = mod.Import(encryptionService.GetMethod("DecryptFromRvaDouble", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaDouble); - _decryptFromRvaBytes = mod.Import(encryptionService.GetMethod("DecryptFromRvaBytes", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaBytes); - _decryptFromRvaString = mod.Import(encryptionService.GetMethod("DecryptFromRvaString", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); - Assert.IsNotNull(_decryptFromRvaString); - } - - private ModuleDef _module; - private IMethod _castIntAsFloat; - private IMethod _castLongAsDouble; - private IMethod _castFloatAsInt; - private IMethod _castDoubleAsLong; - private IMethod _initializeArray; + private readonly ModuleDef _module; + private readonly Type _encryptionServiceType; private IMethod _encryptBlock; private IMethod _decryptBlock; @@ -98,13 +31,6 @@ namespace Obfuz.Emit private IMethod _decryptFromRvaString; private IMethod _decryptFromRvaBytes; - public IMethod CastIntAsFloat => _castIntAsFloat; - public IMethod CastLongAsDouble => _castLongAsDouble; - public IMethod CastFloatAsInt => _castFloatAsInt; - public IMethod CastDoubleAsLong => _castDoubleAsLong; - - public IMethod InitializedArrayMethod => _initializeArray; - public IMethod EncryptBlock => _encryptBlock; public IMethod DecryptBlock => _decryptBlock; @@ -128,5 +54,140 @@ namespace Obfuz.Emit public IMethod DecryptFromRvaBytes => _decryptFromRvaBytes; public IMethod DecryptFromRvaString => _decryptFromRvaString; + public EncryptionServiceMetadataImporter(ModuleDef mod, Type encryptionServiceType) + { + _module = mod; + _encryptionServiceType = encryptionServiceType; + _encryptBlock = mod.Import(encryptionServiceType.GetMethod("EncryptBlock", new[] { typeof(byte[]), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptBlock); + _decryptBlock = mod.Import(encryptionServiceType.GetMethod("DecryptBlock", new[] { typeof(byte[]), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptBlock); + _encryptInt = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptInt); + _decryptInt = mod.Import(encryptionServiceType.GetMethod("Decrypt", new[] { typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptInt); + _encryptLong = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(long), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptLong); + _decryptLong = mod.Import(encryptionServiceType.GetMethod("Decrypt", new[] { typeof(long), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptLong); + _encryptFloat = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(float), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptFloat); + _decryptFloat = mod.Import(encryptionServiceType.GetMethod("Decrypt", new[] { typeof(float), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFloat); + _encryptDouble = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(double), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptDouble); + _decryptDouble = mod.Import(encryptionServiceType.GetMethod("Decrypt", new[] { typeof(double), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptDouble); + _encryptString = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(string), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptString); + _decryptString = mod.Import(encryptionServiceType.GetMethod("DecryptString", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptString); + _encryptBytes = mod.Import(encryptionServiceType.GetMethod("Encrypt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_encryptBytes); + _decryptBytes = mod.Import(encryptionServiceType.GetMethod("Decrypt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptBytes); + + _decryptFromRvaInt = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaInt", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaInt); + _decryptFromRvaLong = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaLong", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaLong); + _decryptFromRvaFloat = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaFloat", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaFloat); + _decryptFromRvaDouble = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaDouble", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaDouble); + _decryptFromRvaBytes = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaBytes", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaBytes); + _decryptFromRvaString = mod.Import(encryptionServiceType.GetMethod("DecryptFromRvaString", new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) })); + Assert.IsNotNull(_decryptFromRvaString); + } + } + + public class DefaultMetadataImporter : GroupByModuleEntityBase + { + private readonly EncryptionScopeProvider _encryptionScopeProvider; + private EncryptionScopeInfo _encryptionScope; + private EncryptionServiceMetadataImporter _defaultEncryptionServiceMetadataImporter; + + + private EncryptionServiceMetadataImporter _staticDefaultEncryptionServiceMetadataImporter; + private EncryptionServiceMetadataImporter _dynamicDefaultEncryptionServiceMetadataImporter; + + public DefaultMetadataImporter(EncryptionScopeProvider encryptionScopeProvider) + { + _encryptionScopeProvider = encryptionScopeProvider; + } + + public override void Init(ModuleDef mod) + { + _module = mod; + _encryptionScope = _encryptionScopeProvider.GetScope(mod); + var constUtilityType = typeof(ConstUtility); + + _castIntAsFloat = mod.Import(constUtilityType.GetMethod("CastIntAsFloat")); + Assert.IsNotNull(_castIntAsFloat, "CastIntAsFloat not found"); + _castLongAsDouble = mod.Import(constUtilityType.GetMethod("CastLongAsDouble")); + Assert.IsNotNull(_castLongAsDouble, "CastLongAsDouble not found"); + _castFloatAsInt = mod.Import(constUtilityType.GetMethod("CastFloatAsInt")); + Assert.IsNotNull(_castFloatAsInt, "CastFloatAsInt not found"); + _castDoubleAsLong = mod.Import(constUtilityType.GetMethod("CastDoubleAsLong")); + Assert.IsNotNull(_castDoubleAsLong, "CastDoubleAsLong not found"); + + _initializeArray = mod.Import(typeof(System.Runtime.CompilerServices.RuntimeHelpers).GetMethod("InitializeArray", new[] { typeof(Array), typeof(RuntimeFieldHandle) })); + Assert.IsNotNull(_initializeArray); + + _staticDefaultEncryptionServiceMetadataImporter = new EncryptionServiceMetadataImporter(mod, typeof(EncryptionService)); + _dynamicDefaultEncryptionServiceMetadataImporter = new EncryptionServiceMetadataImporter(mod, typeof(EncryptionService)); + if (_encryptionScopeProvider.IsDynamicSecretAssembly(mod)) + { + _defaultEncryptionServiceMetadataImporter = _dynamicDefaultEncryptionServiceMetadataImporter; + } + else + { + _defaultEncryptionServiceMetadataImporter = _staticDefaultEncryptionServiceMetadataImporter; + } + } + + public EncryptionServiceMetadataImporter GetEncryptionServiceMetadataImporterOfModule(ModuleDef mod) + { + return _encryptionScopeProvider.IsDynamicSecretAssembly(mod) ? _dynamicDefaultEncryptionServiceMetadataImporter : _staticDefaultEncryptionServiceMetadataImporter; + } + + private ModuleDef _module; + private IMethod _castIntAsFloat; + private IMethod _castLongAsDouble; + private IMethod _castFloatAsInt; + private IMethod _castDoubleAsLong; + private IMethod _initializeArray; + + public IMethod CastIntAsFloat => _castIntAsFloat; + public IMethod CastLongAsDouble => _castLongAsDouble; + public IMethod CastFloatAsInt => _castFloatAsInt; + public IMethod CastDoubleAsLong => _castDoubleAsLong; + + public IMethod InitializedArrayMethod => _initializeArray; + + public IMethod EncryptBlock => _defaultEncryptionServiceMetadataImporter.EncryptBlock; + public IMethod DecryptBlock => _defaultEncryptionServiceMetadataImporter.DecryptBlock; + + public IMethod EncryptInt => _defaultEncryptionServiceMetadataImporter.EncryptInt; + public IMethod DecryptInt => _defaultEncryptionServiceMetadataImporter.DecryptInt; + public IMethod EncryptLong => _defaultEncryptionServiceMetadataImporter.EncryptLong; + public IMethod DecryptLong => _defaultEncryptionServiceMetadataImporter.DecryptLong; + public IMethod EncryptFloat => _defaultEncryptionServiceMetadataImporter.EncryptFloat; + public IMethod DecryptFloat => _defaultEncryptionServiceMetadataImporter.DecryptFloat; + public IMethod EncryptDouble => _defaultEncryptionServiceMetadataImporter.EncryptDouble; + public IMethod DecryptDouble => _defaultEncryptionServiceMetadataImporter.DecryptDouble; + public IMethod EncryptString => _defaultEncryptionServiceMetadataImporter.EncryptString; + public IMethod DecryptString => _defaultEncryptionServiceMetadataImporter.DecryptString; + public IMethod EncryptBytes => _defaultEncryptionServiceMetadataImporter.EncryptBytes; + public IMethod DecryptBytes => _defaultEncryptionServiceMetadataImporter.DecryptBytes; + + public IMethod DecryptFromRvaInt => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaInt; + public IMethod DecryptFromRvaLong => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaLong; + public IMethod DecryptFromRvaFloat => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaFloat; + public IMethod DecryptFromRvaDouble => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaDouble; + public IMethod DecryptFromRvaBytes => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaBytes; + public IMethod DecryptFromRvaString => _defaultEncryptionServiceMetadataImporter.DecryptFromRvaString; + } } diff --git a/Editor/Emit/GroupByModuleEntityManager.cs b/Editor/Emit/GroupByModuleEntityManager.cs index 2e85e41..860bdf8 100644 --- a/Editor/Emit/GroupByModuleEntityManager.cs +++ b/Editor/Emit/GroupByModuleEntityManager.cs @@ -58,9 +58,9 @@ namespace Obfuz.Emit return managers; } - public DefaultMetadataImporter GetDefaultModuleMetadataImporter(ModuleDef module) + public DefaultMetadataImporter GetDefaultModuleMetadataImporter(ModuleDef module, EncryptionScopeProvider encryptionScopeProvider) { - return GetEntity(module); + return GetEntity(module, () => new DefaultMetadataImporter(encryptionScopeProvider)); } } } diff --git a/Editor/EncryptionVM/Instructions/AddInstruction.cs b/Editor/EncryptionVM/Instructions/AddInstruction.cs index c75d943..2681fff 100644 --- a/Editor/EncryptionVM/Instructions/AddInstruction.cs +++ b/Editor/EncryptionVM/Instructions/AddInstruction.cs @@ -14,22 +14,22 @@ namespace Obfuz.EncryptionVM.Instructions } public override int Encrypt(int value, int[] secretKey, int salt) { - return (value ^ secretKey[_opKeyIndex] ^ salt) + _addValue; + return ((value + secretKey[_opKeyIndex]) ^ salt) + _addValue; } public override int Decrypt(int value, int[] secretKey, int salt) { - return (value - _addValue) ^ secretKey[_opKeyIndex] ^ salt; + return ((value - _addValue) ^ salt) - secretKey[_opKeyIndex]; } public override void GenerateEncryptCode(List lines, string indent) { - lines.Add(indent + $"value = (value ^ _secretKey[{_opKeyIndex}] ^ salt) + {_addValue};"); + lines.Add(indent + $"value = ((value + _secretKey[{_opKeyIndex}]) ^ salt) + {_addValue};"); } public override void GenerateDecryptCode(List lines, string indent) { - lines.Add(indent + $"value = (value - {_addValue}) ^ _secretKey[{_opKeyIndex}] ^ salt;"); + lines.Add(indent + $"value = ((value - {_addValue}) ^ salt) - _secretKey[{_opKeyIndex}];"); } } } diff --git a/Editor/EncryptionVM/Instructions/XorInstruction.cs b/Editor/EncryptionVM/Instructions/XorInstruction.cs index a10d526..ec5fb9f 100644 --- a/Editor/EncryptionVM/Instructions/XorInstruction.cs +++ b/Editor/EncryptionVM/Instructions/XorInstruction.cs @@ -15,22 +15,22 @@ namespace Obfuz.EncryptionVM.Instructions public override int Encrypt(int value, int[] secretKey, int salt) { - return (value + secretKey[_opKeyIndex] + salt) ^ _xorValue; + return ((value ^ secretKey[_opKeyIndex]) + salt) ^ _xorValue; } public override int Decrypt(int value, int[] secretKey, int salt) { - return (value ^ _xorValue) - secretKey[_opKeyIndex] - salt; + return ((value ^ _xorValue) - salt) ^ secretKey[_opKeyIndex]; } public override void GenerateEncryptCode(List lines, string indent) { - lines.Add(indent + $"value = (value + _secretKey[{_opKeyIndex}] + salt) ^ {_xorValue};"); + lines.Add(indent + $"value = ((value ^ _secretKey[{_opKeyIndex}]) + salt) ^ {_xorValue};"); } public override void GenerateDecryptCode(List lines, string indent) { - lines.Add(indent + $"value = (value ^ {_xorValue}) - _secretKey[{_opKeyIndex}] - salt;"); + lines.Add(indent + $"value = ((value ^ {_xorValue}) - salt) ^ _secretKey[{_opKeyIndex}];"); } } } diff --git a/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs b/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs index c0574f4..e171909 100644 --- a/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs +++ b/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs @@ -33,7 +33,7 @@ namespace Obfuz.ObfusPasses.CallObfus MethodSig sharedMethodSig = MetaUtil.ToSharedMethodSig(calledMethod.Module.CorLibTypes, MetaUtil.GetInflatedMethodSig(calledMethod)); ProxyCallMethodData proxyCallMethodData = _proxyCallAllocator.Allocate(callerMethod.Module, calledMethod, callVir); - DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(callerMethod.Module); + DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(callerMethod.Module, _encryptionScopeProvider); if (needCacheCall) { diff --git a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs index 634b15b..52d686a 100644 --- a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs +++ b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs @@ -44,7 +44,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt private DefaultMetadataImporter GetModuleMetadataImporter(MethodDef method) { - return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module); + return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, _encryptionScopeProvider); } public void ObfuscateInt(MethodDef method, bool needCacheValue, int value, List obfuscatedInstructions) diff --git a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs index 1989380..05c9c63 100644 --- a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs +++ b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs @@ -25,7 +25,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt private DefaultMetadataImporter GetMetadataImporter(MethodDef method) { - return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module); + return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, _encryptionScopeProvider); } class FieldEncryptInfo @@ -101,6 +101,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt public override void Encrypt(MethodDef method, FieldDef field, List outputInstructions, Instruction currentInstruction) { DefaultMetadataImporter importer = GetMetadataImporter(method); + EncryptionServiceMetadataImporter encryptionServiceMetadataImporter = importer.GetEncryptionServiceMetadataImporterOfModule(field.Module); FieldEncryptInfo fei = GetFieldEncryptInfo(field); if (fei.fieldType == ElementType.I4 || fei.fieldType == ElementType.U4 || fei.fieldType == ElementType.R4) { @@ -109,7 +110,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt // encrypt outputInstructions.Add(Instruction.CreateLdcI4(fei.encryptOps)); outputInstructions.Add(Instruction.CreateLdcI4(fei.salt)); - outputInstructions.Add(Instruction.Create(OpCodes.Call, importer.EncryptInt)); + outputInstructions.Add(Instruction.Create(OpCodes.Call, encryptionServiceMetadataImporter.EncryptInt)); // xor outputInstructions.Add(Instruction.CreateLdcI4((int)fei.xorValueForZero)); outputInstructions.Add(Instruction.Create(OpCodes.Xor)); @@ -121,7 +122,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt // encrypt outputInstructions.Add(Instruction.CreateLdcI4(fei.encryptOps)); outputInstructions.Add(Instruction.CreateLdcI4(fei.salt)); - outputInstructions.Add(Instruction.Create(OpCodes.Call, importer.EncryptLong)); + outputInstructions.Add(Instruction.Create(OpCodes.Call, encryptionServiceMetadataImporter.EncryptLong)); // xor outputInstructions.Add(Instruction.Create(OpCodes.Ldc_I8, fei.xorValueForZero)); outputInstructions.Add(Instruction.Create(OpCodes.Xor)); @@ -138,6 +139,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt { outputInstructions.Add(currentInstruction.Clone()); DefaultMetadataImporter importer = GetMetadataImporter(method); + EncryptionServiceMetadataImporter encryptionServiceMetadataImporter = importer.GetEncryptionServiceMetadataImporterOfModule(field.Module); FieldEncryptInfo fei = GetFieldEncryptInfo(field); if (fei.fieldType == ElementType.I4 || fei.fieldType == ElementType.U4 || fei.fieldType == ElementType.R4) { @@ -153,7 +155,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt // decrypt outputInstructions.Add(Instruction.CreateLdcI4(fei.encryptOps)); outputInstructions.Add(Instruction.CreateLdcI4(fei.salt)); - outputInstructions.Add(Instruction.Create(OpCodes.Call, importer.DecryptInt)); + outputInstructions.Add(Instruction.Create(OpCodes.Call, encryptionServiceMetadataImporter.DecryptInt)); } else if (fei.fieldType == ElementType.I8 || fei.fieldType == ElementType.U8 || fei.fieldType == ElementType.R8) { @@ -169,7 +171,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt // decrypt outputInstructions.Add(Instruction.CreateLdcI4(fei.encryptOps)); outputInstructions.Add(Instruction.CreateLdcI4(fei.salt)); - outputInstructions.Add(Instruction.Create(OpCodes.Call, importer.DecryptLong)); + outputInstructions.Add(Instruction.Create(OpCodes.Call, encryptionServiceMetadataImporter.DecryptLong)); } else { diff --git a/Editor/ObfuscationPassContext.cs b/Editor/ObfuscationPassContext.cs index 12c327f..5a9a0f2 100644 --- a/Editor/ObfuscationPassContext.cs +++ b/Editor/ObfuscationPassContext.cs @@ -54,6 +54,11 @@ namespace Obfuz return _defaultStaticScope; } } + + public bool IsDynamicSecretAssembly(ModuleDef module) + { + return _dynamicSecretAssemblyNames.Contains(module.Assembly.Name); + } } public class ObfuscationPassContext diff --git a/Editor/Obfuscator.cs b/Editor/Obfuscator.cs index 06954d6..c6dc917 100644 --- a/Editor/Obfuscator.cs +++ b/Editor/Obfuscator.cs @@ -49,10 +49,8 @@ namespace Obfuz { _defaultStaticByteSecret = KeyGenerator.GenerateKey(builder.DefaultStaticSecret, VirtualMachine.SecretKeyLength); _defaultStaticIntSecret = KeyGenerator.ConvertToIntKey(_defaultStaticByteSecret); - SaveKey(_defaultStaticByteSecret, builder.DefaultStaticSecretOutputPath); _defaultDynamicByteSecret = KeyGenerator.GenerateKey(builder.DefaultDynamicSecret, VirtualMachine.SecretKeyLength); _defaultDynamicIntSecret = KeyGenerator.ConvertToIntKey(_defaultDynamicByteSecret); - SaveKey(_defaultDynamicByteSecret, builder.DefaultDynamicSecretOutputPath); _dynamicSecretAssemblyNames = new HashSet(builder.DynamicSecretAssemblyNames); @@ -83,13 +81,6 @@ namespace Obfuz _pipeline2.AddPass(new RemoveObfuzAttributesPass()); } - public static void SaveKey(byte[] secret, string secretOutputPath) - { - FileUtil.CreateParentDir(secretOutputPath); - File.WriteAllBytes(secretOutputPath, secret); - Debug.Log($"Save secret key to {secretOutputPath}, secret length:{secret.Length}"); - } - public void Run() { FileUtil.RecreateDir(_obfuscatedAssemblyOutputDir); @@ -263,6 +254,13 @@ namespace Obfuz { var defaultStaticScope = CreateEncryptionScope(_defaultStaticByteSecret, _defaultStaticIntSecret); var defaultDynamicScope = CreateEncryptionScope(_defaultDynamicByteSecret, _defaultDynamicIntSecret); + foreach (string dynamicAssName in _dynamicSecretAssemblyNames) + { + if (!_toObfuscatedAssemblyNames.Contains(dynamicAssName)) + { + throw new Exception($"Dynamic secret assembly `{dynamicAssName}` should be in the toObfuscatedAssemblyNames list!"); + } + } return new EncryptionScopeProvider(defaultStaticScope, defaultDynamicScope, _dynamicSecretAssemblyNames); } diff --git a/Editor/Unity/ObfuzMenu.cs b/Editor/Unity/ObfuzMenu.cs index 3aa9dbd..d00ce53 100644 --- a/Editor/Unity/ObfuzMenu.cs +++ b/Editor/Unity/ObfuzMenu.cs @@ -29,13 +29,19 @@ namespace Obfuz.Unity SecretSettings settings = ObfuzSettings.Instance.secretSettings; var staticSecretBytes = KeyGenerator.GenerateKey(settings.defaultStaticSecret, VirtualMachine.SecretKeyLength); - Obfuscator.SaveKey(staticSecretBytes, settings.DefaultStaticSecretKeyOutputPath); + 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); + SaveKey(dynamicSecretBytes, settings.DefaultDynamicSecretKeyOutputPath); Debug.Log($"Save dynamic secret key to {settings.DefaultDynamicSecretKeyOutputPath}"); } + private static void SaveKey(byte[] secret, string secretOutputPath) + { + FileUtil.CreateParentDir(secretOutputPath); + File.WriteAllBytes(secretOutputPath, secret); + } + [MenuItem("Obfuz/Documents/Quick Start")] public static void OpenQuickStart() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/beginner/quickstart");