Replace Serilog, Autofac, pocket and Microsoft.* dependencies

README.md

@@ -14,7 +14,7 @@ BitMono is a free, open-source C# obfuscator that was initially designed and int
 
 BitMono uses [AsmResolver][asmresolver] instead of [dnlib][dnlib] (which we used in the past) for handling assemblies. If you have questions or issues, please let us know [here][bitmono_issues]. Download the latest version of BitMono [here][bitmono_releases].
 
-You can also use BitMono as an engine to build custom obfuscators. It is built using dependency injection (DI) using [Autofac][autofac_repo] and follows the latest C# best practices.
+You can also use BitMono as an engine to build custom obfuscators. It is built using dependency injection (DI) with a lightweight custom container based on [MinIoC][minioc_repo] (we used [Autofac][autofac_repo] in the past) and follows the latest C# best practices.
 
 <p align="center">
 <img src="https://raw.githubusercontent.com/sunnamed434/BitMono/main/resources/images/preview/before-after.png"
@@ -187,6 +187,7 @@ Credits
 [bitmono_nuget_packages]: https://www.nuget.org/profiles/BitMono
 [bitmono_nuget_shield]: https://img.shields.io/nuget/v/BitMono.Core.svg
 [autofac_repo]: https://github.com/autofac/Autofac
+[minioc_repo]: https://github.com/pjc0247/minioffice.ioc
 [unityengine_mainpage]: https://unity.com
 [mono_mainpage]: https://www.mono-project.com
 

docs/source/developers/configuration.rst

@@ -2,7 +2,7 @@ Configuration
 =============
 
 Injecting Configuration(s) in Protection constructor.
-BitMono have such configuartions and all of them you can inject in your protection constructor:
+BitMono have such configurations and all of them you can inject in your protection constructor:
 
 - ProtectionSettings
 - CriticalsSettings
@@ -19,15 +19,15 @@ Here's example how to do that:
 		private readonly ProtectionSettings _protectionSettings;
 		private readonly CriticalsSettings _criticalsSettings;
 		private readonly ObfuscationSettings _obfuscationSettings;
-	
+
 		public MagicProtection(
-			IOptions<ProtectionSettings> protectionSettings,
-			IOptions<CriticalsSettings> criticalsSettings,
-			IOptions<ObfuscationSettings> obfuscationSettings,
-			IServiceProvider serviceProvider) : base(serviceProvider)
+			ProtectionSettings protectionSettings,
+			CriticalsSettings criticalsSettings,
+			ObfuscationSettings obfuscationSettings,
+			IBitMonoServiceProvider serviceProvider) : base(serviceProvider)
 		{
-			_protectionSettings = protectionSettings.Value;
-			_criticalsSettings = criticalsSettings.Value;
-			_obfuscationSettings = obfuscationSettings.Value;
-		}	
+			_protectionSettings = protectionSettings;
+			_criticalsSettings = criticalsSettings;
+			_obfuscationSettings = obfuscationSettings;
+		}
 	}

docs/source/developers/first-protection.rst

@@ -18,10 +18,10 @@ Create your protection in the ``BitMono.Protections`` namespace.
 	public class StandardProtection : Protection
 	{
 	    // Inject services right here
-	    public StandardProtection(IServiceProvider serviceProvider) : base(serviceProvider)
+	    public StandardProtection(IBitMonoServiceProvider serviceProvider) : base(serviceProvider)
 	    {
 	    }
-	
+
 	    public override Task ExecuteAsync()
 	    {
 	        // All protection are intended to be async, so you can simply await your things, or if you don't have,

docs/source/faq/disable-path-masking.rst

@@ -1,58 +1,11 @@
 How to disable path masking?
 ============================
 
-You're probably getting a message with the file/directory or just a path ``(***\things)``, and you might have the same folder twice somewhere, and you need to see the full path without masking if this is what you're looking for, all instructions how to do that are provided here.
+.. note::
 
-Open-up ``logging.json`` in the root of the downloaded BitMono, edit this file, and remove this:
+   Path masking was a feature in older versions of BitMono that used Serilog for logging.
+   Since BitMono now uses a lightweight custom logger, path masking is no longer applied by default.
 
-.. code-block:: json
+In current versions of BitMono, file paths are displayed in full without any masking. If you're seeing masked paths like ``(***\things)``, you may be using an older version of BitMono.
 
-	"Enrich": [
-            {
-                "Name": "WithSensitiveDataMasking",
-                "Args": {
-                    "options": {
-                        "MaskValue": "***\\",
-                        "MaskProperties": [ "path", "directory", "file" ],
-                        "MaskingOperators": [ "BitMono.Host.Extensions.PathMaskingOperator, BitMono.Host" ]
-                    }
-                }
-            },
-        ],
-
-
-So, after edit ``logging.json`` looks like this:
-
-.. code-block:: json
-
-	{
-	    "Serilog": {
-	        "Using": [
-	            "Serilog",
-	            "Serilog.Sinks.Console",
-	            "Serilog.Sinks.File",
-	            "Serilog.Sinks.Async",
-	            "Serilog.Enrichers.Sensitive"
-	        ],
-	        "WriteTo": [
-	            {
-	                "Name": "Async",
-	                "Args": {
-	                    "configure": [
-	                        {
-	                            "Name": "File",
-	                            "Args": {
-	                                "path": "logs/bitmono-{{date}}.log",
-	                                "outputTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}][{SourceContext}] {Message:lj}{NewLine}{Exception}"
-	                            }
-	                        }
-	                    ]
-	                }
-	            }
-	        ],
-	        "Enrich": [
-	            "FromLogContext"
-	        ],
-	        "MinimumLevel": "Debug"
-	    }
-	}
+To get full path visibility, simply update to the latest version of BitMono from the `releases page <https://github.com/sunnamed434/BitMono/releases/latest>`_.

docs/source/usage/how-to-use.rst

@@ -247,8 +247,7 @@ After importing, your project will contain:
        ├── BitMono.CLI.exe                 # The actual obfuscation tool
        ├── protections.json                # Protection settings
        ├── obfuscation.json                # Obfuscation settings
-       ├── criticals.json                  # What not to obfuscate
-       └── logging.json                    # Logging configuration
+       └── criticals.json                  # What not to obfuscate
 
 Configuration
 ~~~~~~~~~~~~~

src/BitMono.API/GlobalUsings.cs

@@ -1,11 +1,10 @@
 global using AsmResolver.DotNet;
-global using Microsoft.Extensions.Configuration;
-global using Microsoft.Extensions.DependencyInjection;
 global using NullGuard;
 global using System;
 global using System.Collections.Generic;
 global using System.Diagnostics.CodeAnalysis;
 global using System.Threading.Tasks;
 global using BitMono.API.Protections;
 global using JetBrains.Annotations;
-global using IModule = Autofac.Core.IModule;
+global using BitMono.Shared.DependencyInjection;
+global using BitMono.Shared.Logging;

src/BitMono.CLI/GlobalUsings.cs

@@ -1,28 +1,24 @@
-global using Autofac;
 global using BitMono.CLI.Modules;
 global using BitMono.Host;
+global using BitMono.Host.Extensions;
+global using BitMono.Host.Ioc;
 global using BitMono.Host.Modules;
 global using BitMono.Obfuscation;
-global using System;
-global using System.Diagnostics;
-global using System.Diagnostics.CodeAnalysis;
-global using System.IO;
-global using System.Threading;
-global using System.Threading.Tasks;
-global using BitMono.Host.Extensions;
-global using BitMono.Host.Configurations;
 global using BitMono.Obfuscation.Files;
 global using BitMono.Obfuscation.Starter;
+global using BitMono.Shared;
+global using BitMono.Shared.Configuration;
+global using BitMono.Shared.DependencyInjection;
+global using BitMono.Shared.Logging;
 global using BitMono.Shared.Models;
 global using BitMono.Utilities.Paths;
 global using CommandLine;
-global using Microsoft.Extensions.DependencyInjection;
-global using Microsoft.Extensions.Options;
-global using Microsoft.Extensions.Configuration;
-global using Pocket.Extensions;
-global using Serilog;
+global using BitMono.Shared.Extensions;
+global using System;
 global using System.Collections.Generic;
+global using System.Diagnostics;
+global using System.Diagnostics.CodeAnalysis;
+global using System.IO;
 global using System.Linq;
-global using BitMono.Shared;
-global using Serilog.Configuration;
-global using ILogger = Serilog.ILogger;
+global using System.Threading;
+global using System.Threading.Tasks;

src/BitMono.CLI/Modules/OptionsObfuscationNeedsFactory.cs

@@ -29,13 +29,11 @@ public OptionsObfuscationNeedsFactory(string[] args)
         {
             if (options.ObfuscationFile != null && File.Exists(options.ObfuscationFile))
             {
-                var obfuscationConfig = new BitMonoObfuscationConfiguration(options.ObfuscationFile);
-                obfuscationSettings = obfuscationConfig.Configuration.Get<ObfuscationSettings>();
+                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(options.ObfuscationFile);
             }
             else if (File.Exists(KnownConfigNames.Obfuscation))
             {
-                var obfuscationConfig = new BitMonoObfuscationConfiguration();
-                obfuscationSettings = obfuscationConfig.Configuration.Get<ObfuscationSettings>();
+                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(KnownConfigNames.Obfuscation);
             }
 
             if (obfuscationSettings != null && options.NoWatermark)

src/BitMono.CLI/Modules/ReadlineObfuscationNeedsFactory.cs

@@ -36,14 +36,13 @@ public ObfuscationNeeds Create(CancellationToken cancellationToken)
         {
             if (File.Exists(obfuscationFile ?? KnownConfigNames.Obfuscation))
             {
-                var obfuscationConfig = new BitMonoObfuscationConfiguration(obfuscationFile);
-                obfuscationSettings = obfuscationConfig.Configuration.Get<ObfuscationSettings>();
+                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(obfuscationFile ?? KnownConfigNames.Obfuscation);
             }
 
             if (File.Exists(KnownConfigNames.Protections))
             {
-                var protectionsConfig = new BitMonoProtectionsConfiguration();
-                protectionSettings = protectionsConfig.Configuration.Get<ProtectionSettings>()?.Protections;
+                var loadedSettings = SettingsLoader.Load<ProtectionSettings>(KnownConfigNames.Protections);
+                protectionSettings = loadedSettings?.Protections;
             }
         }
         catch (Exception ex)

src/BitMono.CLI/Program.cs

@@ -8,13 +8,13 @@ internal class Program
         $"BitMono v{FileVersionInfo.GetVersionInfo(typeof(Program).Assembly.Location).FileVersion}";
     private static readonly string AsciiArt = $"""
 
-                                                      ___  _ __  __  ___
-                                                     / _ )(_) /_/  |/  /__  ___  ___
-                                                    / _  / / __/ /|_/ / _ \/ _ \/ _ \
-                                                   /____/_/\__/_/  /_/\___/_//_/\___/
-                                                   https://github.com/sunnamed434/BitMono
-                                                   {BitMonoFileVersionText}
-                                               """;
+                                                  ___  _ __  __  ___
+                                                 / _ )(_) /_/  |/  /__  ___  ___
+                                                / _  / / __/ /|_/ / _ \/ _ \/ _ \
+                                               /____/_/\__/_/  /_/\___/_//_/\___/
+                                               https://github.com/sunnamed434/BitMono
+                                               {BitMonoFileVersionText}
+                                           """;
 
     private static async Task<int> Main(string[] args)
     {
@@ -33,21 +33,17 @@ private static async Task<int> Main(string[] args)
             }
 
             var module = new BitMonoModule(
-                configureContainer => configureContainer.AddProtections(),
-                configureServices => configureServices.AddConfigurations(
-                    protectionSettings: needs.ProtectionSettings,
-                    criticalsFile: needs.CriticalsFile,
-                    obfuscationFile: needs.ObfuscationFile,
-                    loggingFile: needs.LoggingFile,
-                    protectionsFile: needs.ProtectionsFile,
-                    obfuscationSettings: needs.ObfuscationSettings),
-                configureLogger => configureLogger.WriteTo.AddConsoleLogger(),
-                loggingFile: needs.LoggingFile);
+                configureContainer: container => container.AddProtections(),
+                obfuscationSettings: needs.ObfuscationSettings,
+                protectionSettings: needs.ProtectionSettings,
+                criticalsFile: needs.CriticalsFile,
+                obfuscationFile: needs.ObfuscationFile,
+                protectionsFile: needs.ProtectionsFile);
 
             var app = new BitMonoApplication().RegisterModule(module);
-            await using var serviceProvider = await app.BuildAsync(CancellationToken);
+            var serviceProvider = await app.BuildAsync(CancellationToken);
 
-            var obfuscation = serviceProvider.GetRequiredService<IOptions<ObfuscationSettings>>().Value;
+            var obfuscation = serviceProvider.GetRequiredService<ObfuscationSettings>();
             var logger = serviceProvider
                 .GetRequiredService<ILogger>()
                 .ForContext<Program>();
@@ -116,4 +112,4 @@ private static void OnCancelKeyPress(object? sender, ConsoleCancelEventArgs e)
         CancellationTokenSource.Cancel();
         e.Cancel = true;
     }
-}
+}

src/BitMono.Core/Analyzing/CriticalBaseTypesCriticalAnalyzer.cs

@@ -6,9 +6,9 @@ public class CriticalBaseTypesCriticalAnalyzer : ICriticalAnalyzer<TypeDefinitio
 {
     private readonly CriticalsSettings _criticalsSettings;
 
-    public CriticalBaseTypesCriticalAnalyzer(IOptions<CriticalsSettings> criticals)
+    public CriticalBaseTypesCriticalAnalyzer(CriticalsSettings criticalsSettings)
     {
-        _criticalsSettings = criticals.Value;
+        _criticalsSettings = criticalsSettings;
     }
 
     public bool NotCriticalToMakeChanges(TypeDefinition type)

src/BitMono.Core/Analyzing/CriticalInterfacesCriticalAnalyzer.cs

@@ -4,9 +4,9 @@ public class CriticalInterfacesCriticalAnalyzer : ICriticalAnalyzer<TypeDefiniti
 {
     private readonly CriticalsSettings _criticalsSettings;
 
-    public CriticalInterfacesCriticalAnalyzer(IOptions<CriticalsSettings> criticals)
+    public CriticalInterfacesCriticalAnalyzer(CriticalsSettings criticalsSettings)
     {
-        _criticalsSettings = criticals.Value;
+        _criticalsSettings = criticalsSettings;
     }
 
     public bool NotCriticalToMakeChanges(TypeDefinition type)

src/BitMono.Core/Analyzing/CriticalMethodsCriticalAnalyzer.cs

@@ -4,9 +4,9 @@ public class CriticalMethodsCriticalAnalyzer : ICriticalAnalyzer<MethodDefinitio
 {
     private readonly CriticalsSettings _criticalsSettings;
 
-    public CriticalMethodsCriticalAnalyzer(IOptions<CriticalsSettings> criticals)
+    public CriticalMethodsCriticalAnalyzer(CriticalsSettings criticalsSettings)
     {
-        _criticalsSettings = criticals.Value;
+        _criticalsSettings = criticalsSettings;
     }
 
     public bool NotCriticalToMakeChanges(MethodDefinition method)

src/BitMono.Core/Analyzing/CriticalMethodsStartsWithAnalyzer.cs

@@ -4,9 +4,9 @@ public class CriticalMethodsStartsWithAnalyzer : ICriticalAnalyzer<MethodDefinit
 {
     private readonly CriticalsSettings _criticalsSettings;
 
-    public CriticalMethodsStartsWithAnalyzer(IOptions<CriticalsSettings> criticals)
+    public CriticalMethodsStartsWithAnalyzer(CriticalsSettings criticalsSettings)
     {
-        _criticalsSettings = criticals.Value;
+        _criticalsSettings = criticalsSettings;
     }
 
     public bool NotCriticalToMakeChanges(MethodDefinition method)