Merge pull request #194 from sunnamed434/fix-obfuscation-attribute-strip

Fix obfuscation attributes strip
sunnamed434 · Aug 18, 2024 · 86f51b9 · 86f51b9
2 parents fb56b60 + 4bb03e8
commit 86f51b9
Show file tree

Hide file tree

Showing 20 changed files with 155 additions and 120 deletions.
diff --git a/src/BitMono.API/Resolvers/IAttributeResolver.cs b/src/BitMono.API/Resolvers/IAttributeResolver.cs
@@ -1,9 +1,9 @@
 namespace BitMono.API.Resolvers;
 
-public interface IAttributeResolver<TModel>
-    where TModel : class
+[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]
+public interface IAttributeResolver<TModel> where TModel : class
 {
-    bool Resolve(string? featureName, IHasCustomAttribute from, out TModel? model);
+    bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out TModel? model);
     bool Resolve(string? featureName, IHasCustomAttribute from);
     bool Resolve(IHasCustomAttribute from);
     bool Resolve(Type featureType, IHasCustomAttribute from);

diff --git a/src/BitMono.API/Resolvers/IMemberResolver.cs b/src/BitMono.API/Resolvers/IMemberResolver.cs
@@ -1,5 +1,6 @@
 namespace BitMono.API.Resolvers;
 
+[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]
 public interface IMemberResolver
 {
     bool Resolve(IProtection protection, IMetadataMember member);

diff --git a/src/BitMono.CLI/Program.cs b/src/BitMono.CLI/Program.cs
@@ -6,13 +6,15 @@ internal class Program
     private static CancellationToken CancellationToken => CancellationTokenSource.Token;
     private static readonly string BitMonoFileVersionText =
         $"BitMono v{FileVersionInfo.GetVersionInfo(typeof(Program).Assembly.Location).FileVersion}";
-    private static readonly string AsciiArt = @$"
-       ___  _ __  __  ___
-      / _ )(_) /_/  |/  /__  ___  ___
-     / _  / / __/ /|_/ / _ \/ _ \/ _ \
-    /____/_/\__/_/  /_/\___/_//_/\___/
-    https://github.com/sunnamed434/BitMono
-    {BitMonoFileVersionText}";
+    private static readonly string AsciiArt = $"""
+
+                                                      ___  _ __  __  ___
+                                                     / _ )(_) /_/  |/  /__  ___  ___
+                                                    / _  / / __/ /|_/ / _ \/ _ \/ _ \
+                                                   /____/_/\__/_/  /_/\___/_//_/\___/
+                                                   https://github.com/sunnamed434/BitMono
+                                                   {BitMonoFileVersionText}
+                                               """;
 
     private static async Task<int> Main(string[] args)
     {
@@ -53,7 +55,7 @@ private static async Task<int> Main(string[] args)
 
             var info = new IncompleteFileInfo(needs.FileName, needs.ReferencesDirectoryName, needs.OutputPath);
             var engine = new BitMonoStarter(serviceProvider);
-            var succeed = await engine.StartAsync(info, CancellationTokenSource.Token);
+            var succeed = await engine.StartAsync(info, CancellationToken);
             if (succeed == false)
             {
                 logger.Fatal("Engine has fatal issues, unable to continue!");

diff --git a/src/BitMono.Core/Analyzing/CriticalMethodsCriticalAnalyzer.cs b/src/BitMono.Core/Analyzing/CriticalMethodsCriticalAnalyzer.cs
@@ -1,6 +1,5 @@
 namespace BitMono.Core.Analyzing;
 
-[UsedImplicitly]
 public class CriticalMethodsCriticalAnalyzer : ICriticalAnalyzer<MethodDefinition>
 {
     private readonly CriticalsSettings _criticalsSettings;

diff --git a/src/BitMono.Core/Contexts/StarterContext.cs b/src/BitMono.Core/Contexts/StarterContext.cs
@@ -1,6 +1,5 @@
 namespace BitMono.Core.Contexts;
 
-[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
 public class StarterContext
 {
 #pragma warning disable CS8618

diff --git a/src/BitMono.Core/Extensions/KeyValuePairsExtensions.cs b/src/BitMono.Core/Extensions/KeyValuePairsExtensions.cs
@@ -11,7 +11,7 @@ public static bool GetValueOrDefault(this Dictionary<string, object> source, str
         }
         return value;
     }
-    public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, out TActual? value)
+    public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, [NotNullWhen(true)] out TActual? value)
         where TActual : TValue
     {
         if (source.TryGetValue(key, out var tempValue))

diff --git a/src/BitMono.Core/Resolvers/AttemptAttributeResolver.cs b/src/BitMono.Core/Resolvers/AttemptAttributeResolver.cs
@@ -2,7 +2,8 @@
 
 public static class AttemptAttributeResolver
 {
-    public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name, out List<CustomAttributeResolve>? attributesResolve)
+    public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name,
+        [NotNullWhen(true)] out List<CustomAttributeResolve>? attributesResolve)
     {
         attributesResolve = CustomAttributeResolver.Resolve(from, @namespace, name);
         return attributesResolve.IsNullOrEmpty() == false;

diff --git a/src/BitMono.Core/Resolvers/AttributeResolver.cs b/src/BitMono.Core/Resolvers/AttributeResolver.cs
@@ -2,7 +2,7 @@
 
 public class AttributeResolver<TModel> : IAttributeResolver<TModel> where TModel : class
 {
-    public virtual bool Resolve(string? featureName, IHasCustomAttribute from, out TModel? model)
+    public virtual bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out TModel? model)
     {
         model = default;
         return false;

diff --git a/src/BitMono.Core/Resolvers/CriticalAttributeResolver.cs b/src/BitMono.Core/Resolvers/CriticalAttributeResolver.cs
@@ -1,8 +1,5 @@
 namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "ForCanBeConvertedToForeach")]
 public class CriticalAttributeResolver : AttributeResolver<CustomAttributeResolve>
 {
     private readonly CriticalsSettings _criticalsSettings;
@@ -13,7 +10,7 @@ public CriticalAttributeResolver(IOptions<CriticalsSettings> criticals)
     }
 
     public override bool Resolve(string? feature, IHasCustomAttribute from,
-        out CustomAttributeResolve? attributeResolve)
+        [NotNullWhen(true)] out CustomAttributeResolve? attributeResolve)
     {
         attributeResolve = null;
         if (_criticalsSettings.UseCriticalAttributes == false)
@@ -22,17 +19,17 @@ public override bool Resolve(string? feature, IHasCustomAttribute from,
         }
 
         var criticalAttributes = _criticalsSettings.CriticalAttributes;
-        for (var i = 0; i < criticalAttributes.Count; i++)
+        foreach (var criticalAttribute in criticalAttributes)
         {
-            var criticalAttribute = criticalAttributes[i];
             if (AttemptAttributeResolver.TryResolve(from, criticalAttribute.Namespace, criticalAttribute.Name,
-                    out var attributesResolve))
+                    out var attributesResolve) == false)
             {
-                attributeResolve = attributesResolve!.First();
-                return true;
+                continue;
             }
-        }
 
+            attributeResolve = attributesResolve.First();
+            return true;
+        }
         return false;
     }
 }
diff --git a/src/BitMono.Core/Resolvers/DoNotResolveMemberResolver.cs b/src/BitMono.Core/Resolvers/DoNotResolveMemberResolver.cs
@@ -1,7 +1,5 @@
 namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "InvertIf")]
 public class DoNotResolveMemberResolver : IMemberResolver
 {
     private readonly RuntimeCriticalAnalyzer _runtimeCriticalAnalyzer;

diff --git a/src/BitMono.Core/Resolvers/NoInliningMethodMemberResolver.cs b/src/BitMono.Core/Resolvers/NoInliningMethodMemberResolver.cs
@@ -1,7 +1,5 @@
 namespace BitMono.Core.Resolvers;
 
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "MergeIntoPattern")]
 public class NoInliningMethodMemberResolver : IMemberResolver
 {
     private readonly ObfuscationSettings _obfuscationSettings;

diff --git a/src/BitMono.Core/Resolvers/ObfuscateAssemblyAttributeResolver.cs b/src/BitMono.Core/Resolvers/ObfuscateAssemblyAttributeResolver.cs
@@ -9,11 +9,11 @@ public class ObfuscateAssemblyAttributeResolver : AttributeResolver<ObfuscateAss
     public ObfuscateAssemblyAttributeResolver(IOptions<ObfuscationSettings> configuration)
     {
         _obfuscationSettings = configuration.Value;
-        _attributeNamespace = typeof(ObfuscateAssemblyAttribute).Namespace;
+        _attributeNamespace = typeof(ObfuscateAssemblyAttribute).Namespace!;
         _attributeName = nameof(ObfuscateAssemblyAttribute);
     }
 
-    public override bool Resolve(string? feature, IHasCustomAttribute from, out ObfuscateAssemblyAttributeData? model)
+    public override bool Resolve(string? feature, IHasCustomAttribute from, [NotNullWhen(true)] out ObfuscateAssemblyAttributeData? model)
     {
         model = null;
         if (_obfuscationSettings.ObfuscateAssemblyAttributeObfuscationExclude == false)
@@ -25,11 +25,24 @@ public override bool Resolve(string? feature, IHasCustomAttribute from, out Obfu
         {
             return false;
         }
+        var attribute = attributesResolve.First();
+        var namedValues = attribute.NamedValues;
+        if (namedValues == null)
+        {
+            return false;
+        }
+        var fixedValues = attribute.FixedValues;
+        if (fixedValues == null || fixedValues.Count == 0)
+        {
+            return false;
+        }
+        if (fixedValues.ElementAtOrDefault(0) is not bool assemblyIsPrivate)
+        {
+            return false;
+        }
 
-        var attribute = attributesResolve!.First();
-        var assemblyIsPrivate = attribute.FixedValues![0] is bool;
         var stripAfterObfuscation =
-            attribute.NamedValues!.GetValueOrDefault(nameof(ObfuscateAssemblyAttribute.StripAfterObfuscation),
+            namedValues.GetValueOrDefault(nameof(ObfuscateAssemblyAttribute.StripAfterObfuscation),
                 defaultValue: true);
         model = new ObfuscateAssemblyAttributeData(assemblyIsPrivate, stripAfterObfuscation, attribute.Attribute);
         return true;

diff --git a/src/BitMono.Core/Resolvers/ObfuscationAttributeResolver.cs b/src/BitMono.Core/Resolvers/ObfuscationAttributeResolver.cs
@@ -1,8 +1,6 @@
 namespace BitMono.Core.Resolvers;
 
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "ForCanBeConvertedToForeach")]
-public class ObfuscationAttributeResolver : AttributeResolver<ObfuscationAttributeData>
+public class ObfuscationAttributeResolver : AttributeResolver<IReadOnlyList<ObfuscationAttributeData>>
 {
     private readonly ObfuscationSettings _obfuscationSettings;
     private readonly string _attributeNamespace;
@@ -11,11 +9,11 @@ public class ObfuscationAttributeResolver : AttributeResolver<ObfuscationAttribu
     public ObfuscationAttributeResolver(IOptions<ObfuscationSettings> configuration)
     {
         _obfuscationSettings = configuration.Value;
-        _attributeNamespace = typeof(ObfuscationAttribute).Namespace;
+        _attributeNamespace = typeof(ObfuscationAttribute).Namespace!;
         _attributeName = nameof(ObfuscationAttribute);
     }
 
-    public override bool Resolve(string? featureName, IHasCustomAttribute from, out ObfuscationAttributeData? model)
+    public override bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out IReadOnlyList<ObfuscationAttributeData>? model)
     {
         model = null;
         if (_obfuscationSettings.ObfuscationAttributeObfuscationExclude == false)
@@ -28,37 +26,43 @@ public override bool Resolve(string? featureName, IHasCustomAttribute from, out
             return false;
         }
 
-        for (var i = 0; i < attributesResolve!.Count; i++)
+        var attributes = new List<ObfuscationAttributeData>();
+        foreach (var attribute in attributesResolve)
         {
-            var attribute = attributesResolve[i];
-            if (attribute.NamedValues?.TryGetTypedValue(nameof(ObfuscationAttribute.Feature), out string? feature) == true)
+            var namedValues = attribute.NamedValues;
+            if (namedValues == null)
             {
-                if (feature!.Equals(featureName, StringComparison.OrdinalIgnoreCase))
-                {
-                    var exclude =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
-                            defaultValue: true);
-                    var applyToMembers =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
-                            defaultValue: true);
-                    var stripAfterObfuscation =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.StripAfterObfuscation),
-                            defaultValue: true);
-                    if (exclude)
-                    {
-                        model = new ObfuscationAttributeData
-                        {
-                            Exclude = exclude,
-                            ApplyToMembers = applyToMembers,
-                            StripAfterObfuscation = stripAfterObfuscation,
-                            Feature = feature,
-                            CustomAttribute = attribute.Attribute
-                        };
-                        return true;
-                    }
-                }
+                continue;
             }
+            if (namedValues.TryGetTypedValue(nameof(ObfuscationAttribute.Feature), out string? feature) == false)
+            {
+                continue;
+            }
+            if (feature.Equals(featureName, StringComparison.OrdinalIgnoreCase) == false)
+            {
+                continue;
+            }
+
+            var exclude =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
+                    defaultValue: true);
+            var applyToMembers =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
+                    defaultValue: true);
+            var stripAfterObfuscation =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.StripAfterObfuscation),
+                    defaultValue: true);
+
+            attributes.Add(new ObfuscationAttributeData
+            {
+                Exclude = exclude,
+                ApplyToMembers = applyToMembers,
+                StripAfterObfuscation = stripAfterObfuscation,
+                Feature = feature,
+                CustomAttribute = attribute.Attribute
+            });
         }
-        return false;
+        model = attributes;
+        return true;
     }
 }
diff --git a/src/BitMono.Core/Resolvers/SafeToMakeChangesMemberResolver.cs b/src/BitMono.Core/Resolvers/SafeToMakeChangesMemberResolver.cs
@@ -1,7 +1,5 @@
 namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "ConvertIfStatementToReturnStatement")]
 public class SafeToMakeChangesMemberResolver : IMemberResolver
 {
     private readonly ObfuscationAttributeResolver _obfuscationAttributeResolver;
@@ -29,19 +27,15 @@ public bool Resolve(IProtection protection, IMetadataMember member)
         if (member is IHasCustomAttribute customAttribute)
         {
             var feature = protection.GetName();
-            if (_obfuscationAttributeResolver.Resolve(feature, customAttribute, out var obfuscationAttributeData))
+            if (_obfuscationAttributeResolver.Resolve(feature, customAttribute, out var obfuscationAttributes)
+                && obfuscationAttributes.Any(x => x.Exclude))
             {
-                if (obfuscationAttributeData!.Exclude)
-                {
-                    return false;
-                }
+                return false;
             }
-            if (_obfuscateAssemblyAttributeResolver.Resolve(null, customAttribute, out var obfuscateAssemblyAttributeData))
+            if (_obfuscateAssemblyAttributeResolver.Resolve(null, customAttribute, out var obfuscateAssemblyAttributeData)
+                && obfuscateAssemblyAttributeData!.AssemblyIsPrivate)
             {
-                if (obfuscateAssemblyAttributeData!.AssemblyIsPrivate)
-                {
-                    return false;
-                }
+                return false;
             }
             if (_criticalAttributeResolver.Resolve(feature, customAttribute))
             {

diff --git a/src/BitMono.Host/protections.json b/src/BitMono.Host/protections.json
@@ -2,7 +2,7 @@
   "Protections": [
     {
       "Name": "AntiILdasm",
-      "Enabled": true
+      "Enabled": false
     },
     {
       "Name": "AntiDe4dot",

diff --git a/src/BitMono.Obfuscation/BitMonoObfuscator.cs b/src/BitMono.Obfuscation/BitMonoObfuscator.cs
@@ -232,16 +232,14 @@ private bool OptimizeMacros()
         }
         return true;
     }
-    private bool StripObfuscationAttributes()
+    private void StripObfuscationAttributes()
     {
         if (_obfuscationSettings.StripObfuscationAttributes == false)
         {
-            _logger.Information("Obfuscation attributes stripping is disabled (it's ok)");
-            return true;
+            return;
         }
         var obfuscationAttributesStrip = _obfuscationAttributesStripper.Strip(_context, _protectionsSort!);
         _obfuscationAttributesStripNotifier.Notify(obfuscationAttributesStrip);
-        return true;
     }
     private bool CreatePEImage()
     {

diff --git a/src/BitMono.Obfuscation/Notifiers/ObfuscationAttributesStripNotifier.cs b/src/BitMono.Obfuscation/Notifiers/ObfuscationAttributesStripNotifier.cs
@@ -13,22 +13,22 @@ public void Notify(ObfuscationAttributesStrip obfuscationAttributesStrip)
     {
         if (obfuscationAttributesStrip.ObfuscationAttributesSuccessStrip.IsEmpty() == false)
         {
-            _logger.Information("Successfully stripped {0} obfuscation attribute(s)!",
+            _logger.Information("Successfully stripped {0} obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscationAttributesSuccessStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscateAssemblyAttributesSuccessStrip.IsEmpty() == false)
         {
-            _logger.Information("Successfully stripped {0} assembly obfuscation attribute(s)!",
+            _logger.Information("Successfully stripped {0} assembly obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscateAssemblyAttributesSuccessStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscationAttributesFailStrip.IsEmpty() == false)
         {
-            _logger.Information("Failed to strip {0} assembly obfuscation attribute(s)!",
+            _logger.Information("Failed to strip {0} assembly obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscationAttributesFailStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscateAssemblyAttributesFailStrip.IsEmpty() == false)
         {
-            _logger.Information("Failed to strip {0} obfuscation attribute(s)!",
+            _logger.Information("Failed to strip {0} obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscateAssemblyAttributesFailStrip.Count);
         }
     }