- 修复 FieldEncrypt加密字段未使用字段所在程序集的EncryptionScope而使用自身EncyrptionScope的bug

- 优化，解决 XorInstruction释加0->0映射后，将所有值映射为自身的问题

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)

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

Editor/Emit/DefaultMetadataImporter.cs

@@ -4,77 +4,10 @@ using UnityEngine.Assertions;
 
 namespace Obfuz.Emit
 {
-    public class DefaultMetadataImporter : GroupByModuleEntityBase
+    public class EncryptionServiceMetadataImporter
     {
-        public DefaultMetadataImporter() { }
+        private readonly ModuleDef _module;
-
+        private readonly Type _encryptionServiceType;
-        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<DefaultStaticEncryptionScope>);
-            _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 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<DefaultStaticEncryptionScope>));
+            _dynamicDefaultEncryptionServiceMetadataImporter = new EncryptionServiceMetadataImporter(mod, typeof(EncryptionService<DefaultDynamicEncryptionScope>));
+            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;
+
     }
 }

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<DefaultMetadataImporter>(module);
+            return GetEntity<DefaultMetadataImporter>(module, () => new DefaultMetadataImporter(encryptionScopeProvider));
         }
     }
 }

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<string> 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<string> lines, string indent)
         {
-            lines.Add(indent + $"value = (value  - {_addValue}) ^ _secretKey[{_opKeyIndex}] ^ salt;");
+            lines.Add(indent + $"value = ((value  - {_addValue}) ^ salt) - _secretKey[{_opKeyIndex}];");
         }
     }
 }

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<string> 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<string> lines, string indent)
         {
-            lines.Add(indent + $"value = (value ^ {_xorValue}) - _secretKey[{_opKeyIndex}] - salt;");
+            lines.Add(indent + $"value = ((value ^ {_xorValue}) - salt) ^ _secretKey[{_opKeyIndex}];");
         }
     }
 }

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)
             {

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<Instruction> obfuscatedInstructions)

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<Instruction> 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
             {

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

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<string>(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);
         }
 

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");