Merge pull request #116 from sunnamed434/dev

sunnamed434 · web-flow · commit d2174577a08b · 2023-04-05T15:26:54.000+03:00
Bump new version 0.13.0-alpha.24
diff --git a/BitMono.sln b/BitMono.sln
@@ -61,7 +61,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BitMono.Core.TestCases.Refl
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BitMono.Obfuscation.Tests", "test\BitMono.Obfuscation.Tests\BitMono.Obfuscation.Tests.csproj", "{49E6076C-FEC8-4411-B7AE-4DB6112370C1}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BitMono.Obfuscation.TestCases.CosturaDecompressor", "test\TestBinaries\BitMono.Obfuscation.TestCases.CosturaDecompressor\BitMono.Obfuscation.TestCases.CosturaDecompressor.csproj", "{E73C9803-971F-4F7D-A21B-9097C2EC1A80}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BitMono.Obfuscation.TestCases.CosturaDecompressor", "test\TestBinaries\DotNet\BitMono.Obfuscation.TestCases.CosturaDecompressor\BitMono.Obfuscation.TestCases.CosturaDecompressor.csproj", "{E73C9803-971F-4F7D-A21B-9097C2EC1A80}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,6 @@
 | Versions:                       |
 |---------------------------------|
+| [v0.13.0-alpha](#v0130-alpha24) |
 | [v0.12.2-alpha](#v0122-alpha23) |
 | [v0.12.1-alpha](#v0121-alpha22) |
 | [v0.12.0-alpha](#v0120-alpha21) |
@@ -25,6 +26,18 @@
 | [v0.1.0](#v010)                 |
 
 ---
+### v0.13.0-alpha.24:
+2023-04-05
+#### Added:
+* Return obfuscation success & failure status from BitMono.CLI (0 - Success, 1 - Failure), thanks to [techei](https://github.com/techei).
+* More docs and answers to the questions.
+
+#### Fixed:
+* Assembly resolve [#113](https://github.com/sunnamed434/BitMono/issues/113), thanks to [techei](https://github.com/techei) for the bug report.
+
+#### Changed:
+* Docs information about protections.
+
 ### v0.12.2-alpha.23:
 2023-03-08
 #### Fixed:
diff --git a/docs/faq/unable-to-reference-after-protect.rst b/docs/faq/unable-to-reference-after-protect.rst
@@ -0,0 +1,4 @@
+Unable to reference after protect?
+==================================
+
+You're probably stuck on a problem, when you want to use your ``.dll`` after protection, you protect it via BitMono and try to reference it in IDE or whatever else, you're doing a bit wrong, you need to have an original copy and use it as a reference, and as output folder (i.e Release\...) drop there a protected version of your ``.dll``.
diff --git a/docs/index.rst b/docs/index.rst
@@ -6,14 +6,6 @@ This is the documentation of the BitMono project. BitMono is not only a tool tha
 Table of Contents:
 ------------------
 
-.. toctree::
-   :maxdepth: 1
-   :caption: How to use
-   :name: sec-general
-
-   overview
-
-
 .. toctree::
    :maxdepth: 1
    :caption: Protections
@@ -52,4 +44,5 @@ Table of Contents:
 
    faq/costura-support
    faq/disable-path-masking
+   faq/unable-to-reference-after-protect
    faq/when-and-why-use-bitmono
diff --git a/docs/protections/bitdotnet.rst b/docs/protections/bitdotnet.rst
@@ -1,4 +1,4 @@
-BitDotnet
+BitDotNet
 =========
 
 How it works?
diff --git a/docs/protections/fullrenamer.rst b/docs/protections/fullrenamer.rst
@@ -3,4 +3,6 @@ FullRenamer
 
 How it works?
 -------------
-Protection renames types/methods/fields, however, ignores things that were used in reflection.
+Protection renames types/methods/fields, however, ignores things such as reflection, Unity Methods (Update/FixedUpdate/LateUpdate, i.e all of them), and the most popular frameworks for plugin development in Unity on GitHub - RocketMod, OpenMod, and rust-oxide-umod, you even could specify your methods/types to ignore.
+
+Be careful, because renamer is tricky protection, not always useful, and does not always work properly. But, if you configure BitMono correctly Renamer can be a great protection (I'm about big projects, not crackmes).
diff --git a/docs/protections/stringsencryption.rst b/docs/protections/stringsencryption.rst
@@ -3,4 +3,6 @@ StringsEncryption
 
 How it works?
 -------------
-Protection encrypts strings.
+Protection encrypts strings using basic AES encryption, but not everyone like it because it makes the worse performance of application.
+
+Had big thoughts about `Unmanaged String <https://github.com/MrakDev/UnmanagedString>`_, but, as I tested in Mono it causes problems.
diff --git a/props/SharedProjectProps.props b/props/SharedProjectProps.props
@@ -6,12 +6,12 @@
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/sunnamed434/BitMono</PackageProjectUrl>
     <PackageOwners>sunnamed434</PackageOwners>
-    <PackageVersion>0.12.2-alpha.23</PackageVersion>
+    <PackageVersion>0.13.0-alpha.24</PackageVersion>
     <RepositoryUrl>https://github.com/sunnamed434/BitMono</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <Authors>sunnamed434</Authors>
-    <Version>0.12.2-alpha.23</Version>
-    <InformationalVersion>0.12.2-alpha.23</InformationalVersion>
+    <Version>0.13.0-alpha.24</Version>
+    <InformationalVersion>0.13.0-alpha.24</InformationalVersion>
     <Company>BitMono</Company>
     <Copyright>sunnamed434</Copyright>
     <LangVersion>10</LangVersion>
diff --git a/src/BitMono.CLI/KnownReturnStatuses.cs b/src/BitMono.CLI/KnownReturnStatuses.cs
@@ -0,0 +1,7 @@
+﻿namespace BitMono.CLI;
+
+internal static class KnownReturnStatuses
+{
+    public const int Success = 0;
+    public const int Failure = 1;
+}
diff --git a/src/BitMono.CLI/Program.cs b/src/BitMono.CLI/Program.cs
@@ -1,4 +1,4 @@
-﻿#pragma warning disable CS8604
+#pragma warning disable CS8604
 namespace BitMono.CLI;
 
 internal class Program
@@ -14,8 +14,9 @@ ___  _ __  __  ___
     https://github.com/sunnamed434/BitMono
     {BitMonoFileVersionText}";
 
-    private static async Task Main(string[] args)
+    private static async Task<int> Main(string[] args)
     {
+        var errorCode = KnownReturnStatuses.Success;
         try
         {
             Console.Title = BitMonoFileVersionText;
@@ -33,11 +34,11 @@ private static async Task Main(string[] args)
             var logger = lifetimeScope
                 .Resolve<ILogger>()
                 .ForContext<Program>();
-
             var needs = new ObfuscationNeedsFactory(args, logger).Create();
             if (needs == null)
             {
-                return;
+                errorCode = KnownReturnStatuses.Failure;
+                return errorCode;
             }
 
             Console.Clear();
@@ -53,7 +54,8 @@ private static async Task Main(string[] args)
             {
                 logger.Fatal("Engine has fatal issues, unable to continue!");
                 Console.ReadLine();
-                return;
+                errorCode = KnownReturnStatuses.Failure;
+                return errorCode;
             }
 
             if (obfuscation.OpenFileDestinationInFileExplorer)
@@ -64,8 +66,10 @@ private static async Task Main(string[] args)
         catch (Exception ex)
         {
             Console.WriteLine("Something went wrong! " + ex);
+            errorCode = KnownReturnStatuses.Failure;
         }
         Console.WriteLine("Enter anything to exit!");
         Console.ReadLine();
+        return errorCode;
     }
-}
+}
diff --git a/src/BitMono.Core/Resolvers/AssemblyResolve.cs b/src/BitMono.Core/Resolvers/AssemblyResolve.cs
@@ -2,8 +2,7 @@
 
 public class AssemblyResolve
 {
-    public List<AssemblyReference>? ResolvedReferences { get; set; }
-    public List<AssemblyReference>? FailedToResolveReferences { get; set; }
-    public List<AssemblyReference>? BadImageReferences { get; set; }
+    public List<AssemblyReference> ResolvedReferences { get; set; }
+    public List<AssemblyReference> FailedToResolveReferences { get; set; }
     public bool Succeed { get; set; }
 }
diff --git a/src/BitMono.Core/Resolvers/AssemblyResolver.cs b/src/BitMono.Core/Resolvers/AssemblyResolver.cs
@@ -9,50 +9,55 @@ public static AssemblyResolve Resolve(IEnumerable<byte[]> dependenciesData, Prot
 
         var resolvedReferences = new List<AssemblyReference>();
         var failedToResolveReferences = new List<AssemblyReference>();
-        var badImageReferences = new List<AssemblyReference>();
         var signatureComparer = new SignatureComparer(SignatureComparisonFlags.AcceptNewerVersions);
 
         foreach (var originalReference in context.Module.AssemblyReferences)
         {
             context.ThrowIfCancellationRequested();
 
+            var resolved = false;
+            if (context.AssemblyResolver.HasCached(originalReference))
+            {
+                resolvedReferences.Add(originalReference);
+                continue;
+            }
+            if (failedToResolveReferences.Contains(originalReference) || resolvedReferences.Contains(originalReference))
+            {
+                continue;
+            }
+
             foreach (var data in dependenciesData)
             {
                 context.ThrowIfCancellationRequested();
 
                 try
                 {
                     var definition = AssemblyDefinition.FromBytes(data);
-                    if (context.AssemblyResolver.HasCached(originalReference) == false && signatureComparer.Equals(originalReference, definition))
+                    if (signatureComparer.Equals(originalReference, definition))
                     {
                         context.AssemblyResolver.AddToCache(originalReference, definition);
+                        resolvedReferences.Add(originalReference);
+                        resolved = true;
+                        break;
                     }
                 }
-                catch (BadImageFormatException ex)
+                catch (BadImageFormatException)
                 {
-                    Console.WriteLine("originalRef: " + originalReference.Name + ", " + ex.ToString());
-                    badImageReferences.Add(originalReference);
                 }
             }
-        }
-        var succeed = true;
-        foreach (var originalReference in context.Module.AssemblyReferences)
-        {
-            if (context.AssemblyResolver.HasCached(originalReference))
-            {
-                resolvedReferences.Add(originalReference);
-            }
-            else
+
+            if (resolved == false)
             {
                 failedToResolveReferences.Add(originalReference);
-                succeed = false;
             }
         }
+
+        var succeed = failedToResolveReferences.Count == 0;
+
         return new AssemblyResolve
         {
             ResolvedReferences = resolvedReferences,
             FailedToResolveReferences = failedToResolveReferences,
-            BadImageReferences = badImageReferences,
             Succeed = succeed
         };
     }
diff --git a/src/BitMono.Obfuscation/BitMonoObfuscator.cs b/src/BitMono.Obfuscation/BitMonoObfuscator.cs
@@ -96,10 +96,6 @@ private Task<bool> ResolveDependenciesAsync()
         {
             _logger.Information("Successfully resolved dependency: {0}", reference.FullName);
         }
-        foreach (var reference in assemblyResolve.BadImageReferences)
-        {
-            _logger.Warning("Failed to resolve dependency, this is not a .NET File: {0}", reference.FullName);
-        }
         foreach (var reference in assemblyResolve.FailedToResolveReferences)
         {
             _logger.Warning("Failed to resolve dependency: {0}", reference.FullName);
diff --git a/src/BitMono.Protections/ObjectReturnType.cs b/src/BitMono.Protections/ObjectReturnType.cs
@@ -15,7 +15,7 @@ public override Task ExecuteAsync(ProtectionParameters parameters)
         var systemObject = factory.Object;
         foreach (var method in parameters.Members.OfType<MethodDefinition>())
         {
-            if (method.Signature != null && method.Signature.ReturnsValue(systemBoolean))
+            if (method.Signature != null && method.Signature.ReturnsValueOf(systemBoolean))
             {
                 if (method is { IsConstructor: false, IsVirtual: false, IsSetMethod: false, IsGetMethod: false }
                     && method.NotAsync())
diff --git a/src/BitMono.Utilities/AsmResolver/MethodDefinitionExtensions.cs b/src/BitMono.Utilities/AsmResolver/MethodDefinitionExtensions.cs
@@ -1,6 +1,4 @@
-﻿using TypeAttributes = AsmResolver.PE.DotNet.Metadata.Tables.Rows.TypeAttributes;
-
-namespace BitMono.Utilities.AsmResolver;
+﻿namespace BitMono.Utilities.AsmResolver;
 
 public static class MethodDefinitionExtensions
 {
@@ -37,7 +35,7 @@ public static bool HasParameters(this MethodDefinition source)
     {
         return source.Parameters.Any();
     }
-    public static bool ReturnsValue(this MethodSignature source, TypeSignature typeSignature)
+    public static bool ReturnsValueOf(this MethodSignature source, TypeSignature typeSignature)
     {
         return source.ReturnType.Equals(typeSignature);
     }
diff --git a/src/BitMono.Utilities/GlobalUsings.cs b/src/BitMono.Utilities/GlobalUsings.cs
@@ -14,4 +14,5 @@
 global using System.Reflection;
 global using System.Runtime.CompilerServices;
 global using AsmResolver.DotNet.Signatures;
-global using AsmResolver.DotNet.Signatures.Types;
+global using AsmResolver.DotNet.Signatures.Types;
+global using TypeAttributes = AsmResolver.PE.DotNet.Metadata.Tables.Rows.TypeAttributes;
diff --git a/test/BitMono.Core.Tests/Analyzing/CriticalMethodsCriticalAnalyzerTest.cs b/test/BitMono.Core.Tests/Analyzing/CriticalMethodsCriticalAnalyzerTest.cs
@@ -37,7 +37,9 @@ public void WhenMethodCriticalAnalyzing_AndMethodIsCritical_ThenShouldBeFalse(st
 
         var result = criticalAnalyzer.NotCriticalToMakeChanges(method);
 
-        result.Should().BeFalse();
+        result
+            .Should()
+            .BeFalse();
     }
     [Theory]
     [ClassData(typeof(MethodsData))]
@@ -59,6 +61,8 @@ public void WhenMethodCriticalAnalyzing_AndMethodIsNotCritical_ThenShouldBeTrue(
 
         var result = criticalAnalyzer.NotCriticalToMakeChanges(method);
 
-        result.Should().BeTrue();
+        result
+            .Should()
+            .BeTrue();
     }
 }
diff --git a/test/BitMono.Core.Tests/Analyzing/ReflectionCriticalAnalyzerTest.cs b/test/BitMono.Core.Tests/Analyzing/ReflectionCriticalAnalyzerTest.cs
@@ -16,7 +16,9 @@ public void WhenReflectionCriticalAnalyzing_AndMethodUsesReflectionOfItSelf_Then
 
         var result = criticalAnalyzer.NotCriticalToMakeChanges(method);
 
-        result.Should().BeFalse();
+        result
+            .Should()
+            .BeFalse();
     }
     [Fact]
     [SuppressMessage("ReSharper", "PossibleNullReferenceException")]
@@ -33,8 +35,14 @@ public void WhenReflectionCriticalAnalyzing_AndMethodUses2DifferentReflectionAnd
 
         var result = criticalAnalyzer.NotCriticalToMakeChanges(method);
 
-        result.Should().BeFalse();
-        criticalAnalyzer.CachedMethods.Count.Should().Be(1);
-        criticalAnalyzer.CachedMethods.First().Name.Value.Should().Be(method.Name);
+        result
+            .Should()
+            .BeFalse();
+        criticalAnalyzer.CachedMethods.Count
+            .Should()
+            .Be(1);
+        criticalAnalyzer.CachedMethods.First().Name.Value
+            .Should()
+            .Be(method.Name);
     }
 }
diff --git a/test/BitMono.Core.Tests/Resolvers/NoInliningMethodMemberResolverTest.cs b/test/BitMono.Core.Tests/Resolvers/NoInliningMethodMemberResolverTest.cs
@@ -14,10 +14,12 @@ public void WhenNoInliningMethodResolving_AndMethodHasInliningBit_ThenShouldBeFa
         var module = ModuleDefinition.FromFile(typeof(NoInliningMethods).Assembly.Location);
         var type = module.TopLevelTypes.First(t => t.Name == nameof(NoInliningMethods));
         var method = type.Methods.First(m => m.Name == nameof(NoInliningMethods.NoInliningMethod));
-        
+
         var result = resolver.Resolve(null, method);
 
-        result.Should().BeFalse();
+        result
+            .Should()
+            .BeFalse();
     }
     [Fact]
     public void WhenNoInliningMethodResolving_AndMethodHasNoInliningBit_ThenShouldBeTrue()
@@ -31,9 +33,11 @@ public void WhenNoInliningMethodResolving_AndMethodHasNoInliningBit_ThenShouldBe
         var module = ModuleDefinition.FromFile(typeof(NoInliningMethods).Assembly.Location);
         var type = module.TopLevelTypes.First(t => t.Name == nameof(NoInliningMethods));
         var method = type.Methods.First(m => m.Name == nameof(NoInliningMethods.VoidMethod));
-        
+
         var result = resolver.Resolve(null, method);
 
-        result.Should().BeTrue();
+        result
+            .Should()
+            .BeTrue();
     }
 }
diff --git a/test/BitMono.Core.Tests/Resolvers/ObfuscateAssemblyAttributeResolverTest.cs b/test/BitMono.Core.Tests/Resolvers/ObfuscateAssemblyAttributeResolverTest.cs
@@ -12,9 +12,11 @@ public void WhenObfuscateAssemblyAttributeResolving_AndAssemblyHasObfuscateAssem
         var options = Options.Create(obfuscation);
         var resolver = Setup.ObfuscateAssemblyAttributeResolver(options);
         var module = ModuleDefinition.FromFile(typeof(CustomAttributesInstance).Assembly.Location);
-        
+
         var result = resolver.Resolve(module.Assembly);
 
-        result.Should().BeTrue();
+        result
+            .Should()
+            .BeTrue();
     }
 }
diff --git a/test/BitMono.Core.Tests/Resolvers/ObfuscationAttributeResolverTest.cs b/test/BitMono.Core.Tests/Resolvers/ObfuscationAttributeResolverTest.cs
diff --git a/test/BitMono.Obfuscation.Tests/Abstractions/CosturaReferencesDataResolverTest.cs b/test/BitMono.Obfuscation.Tests/Abstractions/CosturaReferencesDataResolverTest.cs
diff --git a/test/BitMono.Obfuscation.Tests/BitMono.Obfuscation.Tests.csproj b/test/BitMono.Obfuscation.Tests/BitMono.Obfuscation.Tests.csproj
diff --git a/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/BitMono.Obfuscation.TestCases.CosturaDecompressor.csproj b/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/BitMono.Obfuscation.TestCases.CosturaDecompressor.csproj
diff --git a/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/FodyWeavers.xml b/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/FodyWeavers.xml
diff --git a/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/GlobalUsings.cs b/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/GlobalUsings.cs
diff --git a/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/Program.cs b/test/TestBinaries/DotNet/BitMono.Obfuscation.TestCases.CosturaDecompressor/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-BitDotnet`
	`1`	`+BitDotNet`
`2`	`2`	`=========`
`3`	`3`
`4`	`4`	`How it works?`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#pragma warning disable CS8604`
	`1`	`+#pragma warning disable CS8604`
`2`	`2`	`namespace BitMono.CLI;`
`3`	`3`
`4`	`4`	`internal class Program`
`@@ -14,8 +14,9 @@ ___ _ __ __ ___`
`14`	`14`	`https://github.com/sunnamed434/BitMono`
`15`	`15`	`{BitMonoFileVersionText}";`
`16`	`16`
`17`		`- private static async Task Main(string[] args)`
	`17`	`+ private static async Task<int> Main(string[] args)`
`18`	`18`	`{`
	`19`	`+ var errorCode = KnownReturnStatuses.Success;`
`19`	`20`	`try`
`20`	`21`	`{`
`21`	`22`	`Console.Title = BitMonoFileVersionText;`
`@@ -33,11 +34,11 @@ private static async Task Main(string[] args)`
`33`	`34`	`var logger = lifetimeScope`
`34`	`35`	`.Resolve<ILogger>()`
`35`	`36`	`.ForContext<Program>();`
`36`		`-`
`37`	`37`	`var needs = new ObfuscationNeedsFactory(args, logger).Create();`
`38`	`38`	`if (needs == null)`
`39`	`39`	`{`
`40`		`- return;`
	`40`	`+ errorCode = KnownReturnStatuses.Failure;`
	`41`	`+ return errorCode;`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`Console.Clear();`
`@@ -53,7 +54,8 @@ private static async Task Main(string[] args)`
`53`	`54`	`{`
`54`	`55`	`logger.Fatal("Engine has fatal issues, unable to continue!");`
`55`	`56`	`Console.ReadLine();`
`56`		`- return;`
	`57`	`+ errorCode = KnownReturnStatuses.Failure;`
	`58`	`+ return errorCode;`
`57`	`59`	`}`
`58`	`60`
`59`	`61`	`if (obfuscation.OpenFileDestinationInFileExplorer)`
`@@ -64,8 +66,10 @@ private static async Task Main(string[] args)`
`64`	`66`	`catch (Exception ex)`
`65`	`67`	`{`
`66`	`68`	`Console.WriteLine("Something went wrong! " + ex);`
	`69`	`+ errorCode = KnownReturnStatuses.Failure;`
`67`	`70`	`}`
`68`	`71`	`Console.WriteLine("Enter anything to exit!");`
`69`	`72`	`Console.ReadLine();`
	`73`	`+ return errorCode;`
`70`	`74`	`}`
`71`		`-}`
	`75`	`+}`