Initial commit: ADloader v1.0.0 AD domain join utility

Author: OneDeadMachine-Dev

.gitignore

@@ -0,0 +1,78 @@
+## .NET / C# Build Output
+[Bb]in/
+[Oo]bj/
+[Dd]ebug/
+[Rr]elease/
+
+## Publish artifacts
+publish/
+
+## NuGet
+*.nupkg
+*.snupkg
+.nuget/
+**/packages/*
+!**/packages/build/
+
+## Visual Studio
+.vs/
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.rsuser
+
+## Visual Studio Code
+.vscode/
+
+## JetBrains Rider / ReSharper
+.idea/
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+## Agent / AI config (local only)
+.agents/
+.gemini/
+
+## User-specific files
+*.userprefs
+
+## Build results
+[Dd]ebugPublic/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Ll]og/
+[Ll]ogs/
+
+## Test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+TestResult.xml
+
+## Debug symbols
+*.pdb
+
+## Windows-specific
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+## macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+## Misc
+*.log
+*.tmp
+*.temp
+*.bak
+*.swp
+*~

ADLoaderLogo.png

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\ADloader.Domain\ADloader.Domain.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

ADloader.Application/ADloader.Application.csproj

@@ -0,0 +1,41 @@
+namespace ADloader.Application.Common;
+
+/// <summary>
+/// A generic Result class to represent the outcome of business operations.
+/// In Clean Architecture, we prefer this over throwing exceptions for business errors.
+/// </summary>
+public sealed class Result<T>
+{
+    public bool IsSuccess { get; }
+    public T? Value { get; }
+    public string? ErrorMessage { get; }
+
+    // Constructor is private to enforce using factory methods
+    private Result(bool isSuccess, T? value, string? errorMessage)
+    {
+        IsSuccess = isSuccess;
+        Value = value;
+        ErrorMessage = errorMessage;
+    }
+
+    public static Result<T> Success(T value) => new(true, value, null);
+    public static Result<T> Failure(string errorMessage) => new(false, default, errorMessage);
+}
+
+/// <summary>
+/// Non-generic version for operations that don't return a value.
+/// </summary>
+public sealed class Result
+{
+    public bool IsSuccess { get; }
+    public string? ErrorMessage { get; }
+
+    private Result(bool isSuccess, string? errorMessage)
+    {
+        IsSuccess = isSuccess;
+        ErrorMessage = errorMessage;
+    }
+
+    public static Result Success() => new(true, null);
+    public static Result Failure(string errorMessage) => new(false, errorMessage);
+}

ADloader.Application/Common/Result.cs

@@ -0,0 +1,192 @@
+using ADloader.Domain.Interfaces;
+using ADloader.Domain.Models;
+using ADloader.Application.Common;
+using Microsoft.Extensions.Logging;
+using System;
+
+using System.Threading.Tasks;
+
+namespace ADloader.Application.UseCases;
+
+/// <summary>
+/// Main orchestrator use case: checks admin rights, network, user existence,
+/// optionally creates a user (with confirmation), then joins the local machine to the AD domain.
+/// Every step is logged for transparency and diagnostics.
+/// </summary>
+public class JoinDomainUseCase
+{
+    private readonly IActiveDirectoryService _adService;
+    private readonly IDomainJoinService _joinService;
+    private readonly IUserConfirmation _confirmation;
+    private readonly IEnvironmentService _environment;
+    private readonly ILogger<JoinDomainUseCase> _logger;
+
+    public JoinDomainUseCase(
+        IActiveDirectoryService adService,
+        IDomainJoinService joinService,
+        IUserConfirmation confirmation,
+        IEnvironmentService environment,
+        ILogger<JoinDomainUseCase> logger)
+    {
+        _adService = adService;
+        _joinService = joinService;
+        _confirmation = confirmation;
+        _environment = environment;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Executes the full domain-join workflow with pre-flight checks.
+    /// </summary>
+    public async Task<Result> ExecuteAsync(DomainJoinRequest request)
+    {
+        _logger.LogInformation("══════════════════════════════════════");
+        _logger.LogInformation("  ADloader v1.0.0 — Начало работы");
+        _logger.LogInformation("══════════════════════════════════════");
+
+        // --- Pre-flight: Input validation ---
+        if (string.IsNullOrWhiteSpace(request.DomainName))
+        {
+            _logger.LogError("Ошибка: имя домена не указано.");
+            return Result.Failure("Имя домена не может быть пустым.");
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Username))
+        {
+            _logger.LogError("Ошибка: имя пользователя не указано.");
+            return Result.Failure("Имя пользователя не может быть пустым.");
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Password))
+        {
+            _logger.LogError("Ошибка: пароль не указан.");
+            return Result.Failure("Пароль не может быть пустым.");
+        }
+
+        _logger.LogInformation("Домен: {Domain}", request.DomainName);
+        _logger.LogInformation("Пользователь: {User}", request.Username);
+
+        // --- Pre-flight: Check admin rights ---
+        _logger.LogInformation("[Проверка] Права администратора...");
+        if (!_environment.IsRunningAsAdmin())
+        {
+            _logger.LogError("✗ Приложение запущено БЕЗ прав администратора.");
+            _logger.LogError("  Запустите ADloader от имени Администратора (правый клик → Запуск от имени администратора).");
+            return Result.Failure("Для ввода ПК в домен необходимы права администратора. Перезапустите приложение от имени Администратора.");
+        }
+        _logger.LogInformation("✓ Права администратора подтверждены.");
+
+        // --- Pre-flight: Check network ---
+        _logger.LogInformation("[Проверка] Сетевое подключение...");
+        if (!_environment.IsNetworkAvailable())
+        {
+            _logger.LogError("✗ Сетевое подключение отсутствует.");
+            return Result.Failure("Нет сетевого подключения. Проверьте кабель или Wi-Fi.");
+        }
+        _logger.LogInformation("✓ Сеть доступна.");
+
+        // --- Pre-flight: DNS ping to domain ---
+        _logger.LogInformation("[Проверка] Доступность домена '{Domain}'...", request.DomainName);
+        bool domainReachable = await IsDomainReachableAsync(request.DomainName);
+        if (!domainReachable)
+        {
+            _logger.LogWarning("⚠ Не удалось проверить доступность домена по DNS/ping. Продолжаем попытку...");
+        }
+        else
+        {
+            _logger.LogInformation("✓ Домен '{Domain}' доступен.", request.DomainName);
+        }
+
+        // --- Step 1: Check if user exists ---
+        _logger.LogInformation("──────────────────────────────────────");
+        _logger.LogInformation("[Шаг 1] Проверка существования пользователя '{User}'...", request.Username);
+        try
+        {
+            var checkResult = await _adService.UserExistsAsync(
+                request.DomainName, request.Username, request.Username, request.Password);
+
+            if (checkResult.Error != null)
+            {
+                _logger.LogWarning("⚠ Ошибка при проверке пользователя: {Error}. Продолжаем...", checkResult.Error);
+            }
+            else if (checkResult.Exists)
+            {
+                _logger.LogInformation("✓ Пользователь '{User}' найден в домене.", request.Username);
+            }
+            else
+            {
+                _logger.LogWarning("⚠ Пользователь '{User}' НЕ найден в домене.", request.Username);
+
+                // Ask user for confirmation before creating (via DI-injected IUserConfirmation)
+                bool shouldCreate = await _confirmation.ConfirmAsync(
+                    $"Пользователь '{request.Username}' не найден в домене '{request.DomainName}'.\n\nСоздать нового пользователя?");
+
+                if (shouldCreate)
+                {
+                    _logger.LogInformation("[Шаг 1.1] Создание пользователя '{User}'...", request.Username);
+                    var createResult = await _adService.CreateUserAsync(
+                        request.DomainName, request.Username, request.Password, request.Username, request.Password);
+
+                    if (createResult.IsSuccess)
+                    {
+                        _logger.LogInformation("✓ Пользователь '{User}' успешно создан.", request.Username);
+                    }
+                    else
+                    {
+                        _logger.LogError("✗ Не удалось создать пользователя: {Error}", createResult.ErrorMessage);
+                        return Result.Failure($"Ошибка создания пользователя: {createResult.ErrorMessage}");
+                    }
+                }
+                else
+                {
+                    _logger.LogInformation("Пользователь отказался от создания учётной записи.");
+                    _logger.LogInformation("Продолжаем попытку ввода в домен с указанными учётными данными...");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning("⚠ Не удалось проверить пользователя: {Error}. Продолжаем...", ex.Message);
+        }
+
+        // --- Step 2: Join the domain ---
+        _logger.LogInformation("──────────────────────────────────────");
+        _logger.LogInformation("[Шаг 2] Ввод компьютера в домен '{Domain}'...", request.DomainName);
+
+        var joinResult = await _joinService.JoinDomainAsync(request);
+
+        if (!joinResult.IsSuccess)
+        {
+            _logger.LogError("✗ Ошибка ввода в домен: {Error}", joinResult.ErrorMessage);
+            _logger.LogInformation("──────────────────────────────────────");
+            _logger.LogInformation("Советы по устранению:");
+            _logger.LogInformation("  1. Убедитесь, что ПК подключён к сети домена");
+            _logger.LogInformation("  2. Проверьте правильность имени домена (FQDN)");
+            _logger.LogInformation("  3. Убедитесь, что логин и пароль верны");
+            _logger.LogInformation("  4. Проверьте, что учётная запись имеет права на ввод ПК в домен");
+            _logger.LogInformation("  5. Проверьте настройки DNS (должен указывать на контроллер домена)");
+            return Result.Failure($"Ошибка ввода в домен: {joinResult.ErrorMessage}");
+        }
+
+        _logger.LogInformation("══════════════════════════════════════");
+        _logger.LogInformation("✓ Компьютер успешно введён в домен '{Domain}'!", request.DomainName);
+        _logger.LogInformation("  Для применения изменений необходима перезагрузка.");
+        _logger.LogInformation("══════════════════════════════════════");
+
+        return Result.Success();
+    }
+
+    private static async Task<bool> IsDomainReachableAsync(string domainName)
+    {
+        try
+        {
+            using var ping = new System.Net.NetworkInformation.Ping();
+            var reply = await ping.SendPingAsync(domainName, 3000);
+            return reply.Status == System.Net.NetworkInformation.IPStatus.Success;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}

ADloader.Application/UseCases/JoinDomainUseCase.cs

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

ADloader.Domain/ADloader.Domain.csproj

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+
+namespace ADloader.Domain.Interfaces;
+
+/// <summary>
+/// Contract for querying and managing users in Active Directory.
+/// </summary>
+public interface IActiveDirectoryService
+{
+    /// <summary>
+    /// Checks if a user with the given sAMAccountName exists in the specified domain.
+    /// Returns (Exists, Error) — if an error occurs, Exists is false and Error contains the message.
+    /// </summary>
+    Task<(bool Exists, string? Error)> UserExistsAsync(string domainName, string samAccountName, string adminUser, string adminPassword);
+
+    /// <summary>
+    /// Creates a new user account in the specified domain.
+    /// Returns (success, errorMessage).
+    /// </summary>
+    Task<(bool IsSuccess, string ErrorMessage)> CreateUserAsync(
+        string domainName, string samAccountName, string password, string adminUser, string adminPassword);
+}

ADloader.Domain/Interfaces/IActiveDirectoryService.cs

@@ -0,0 +1,18 @@
+using ADloader.Domain.Models;
+using System.Threading.Tasks;
+
+namespace ADloader.Domain.Interfaces;
+
+/// <summary>
+/// Contract for joining the local machine to an Active Directory domain.
+/// Separated from IActiveDirectoryService per the Single Responsibility Principle.
+/// </summary>
+public interface IDomainJoinService
+{
+    /// <summary>
+    /// Joins the current machine to the specified AD domain using the provided credentials.
+    /// </summary>
+    /// <param name="request">Domain name, username, and password.</param>
+    /// <returns>A tuple indicating success and an error message on failure.</returns>
+    Task<(bool IsSuccess, string ErrorMessage)> JoinDomainAsync(DomainJoinRequest request);
+}