AgniGuardian 5.0.0

AgniGuardian v5.0.0

A comprehensive .NET security library that provides advanced runtime protection against tampering, debugging, patching, injection, and other security threats.

🛡️ Advanced Security Features

Core Protection Modules

• Anti-Tamper Protection: Real-time method integrity verification with SHA-256 hashing
• Anti-Debugging: Multi-layered debugger detection (managed, native, timing-based)
• Anti-Patching: Runtime code modification detection with method signature verification
• Anti-Injection: DLL injection and assembly loading monitoring with P/Invoke protection
• Anti-Dump: Memory protection and PE header corruption techniques
• Anti-Decompile: String encryption, control flow obfuscation, and name mangling

Advanced Monitoring Systems

• Real-time Integrity Checking: File system watchers with immediate threat response
• Comprehensive Process Monitor: 100+ malicious process signatures with behavioral analysis
• Runtime Guard: Reflection monitoring and profiler detection
• Network Guard: SSL certificate pinning and proxy detection
• Comprehensive Logging: Structured logging with security event tracking

Enhanced Security Features

• Multi-Framework Support: .NET Framework 4.6.2+ to .NET 8.0+
• Platform Compatibility: Windows-optimized with cross-platform fallbacks
• Attack Reporting: Discord webhook integration with screenshot capture
• Performance Optimized: Minimal overhead with configurable monitoring intervals

Supported Frameworks

AgniGuardian supports multiple .NET frameworks:

• .NET Framework 4.6.2+
• .NET Standard 2.0+
• .NET 6.0+
• .NET 7.0+
• .NET 8.0+

📦 Installation

Install the package via NuGet:

Install-Package AgniGuardian

Or via the .NET CLI:

dotnet add package AgniGuardian

🚀 Super Easy Integration Methods

1. One-Line Integration (Simplest)

using AgniGuardian;

// Just one line - all protections enabled!
Guardian.Initialize();

2. Preset-Based Integration (Recommended)

using AgniGuardian;

// Choose from 7 predefined presets for different scenarios:

// Most applications - balanced security and performance
GuardianPresets.InitializeBalancedProtection("discord-webhook-url");

// Production apps - maximum security
GuardianPresets.InitializeMaximumProtection("discord-webhook-url");

// Performance-critical apps - minimal overhead
GuardianPresets.InitializeLightweightProtection("discord-webhook-url");

// Development - allows debugging and dev tools
GuardianPresets.InitializeDevelopmentProtection();

// Gaming apps - anti-cheat focused with aggressive monitoring
GuardianPresets.InitializeGamingProtection("discord-webhook-url");

// Enterprise apps - comprehensive logging and monitoring
GuardianPresets.InitializeEnterpriseProtection("discord-webhook-url");

// CUSTOM PROTECTION - Selectively disable specific protections
GuardianPresets.InitializeCustomProtection(
    discordWebhookUrl: "webhook-url",
    disableAntiDebugger: true,        // Allow debugging
    disableProcessMonitor: true,      // Don't monitor processes
    disableNetworkGuard: true,        // Allow proxy tools
    enableVerboseLogging: true        // Enable detailed logging
);

2a. Custom Protection Scenarios (New!)

using AgniGuardian;

// Pre-configured custom scenarios for common use cases:

// Development with debugging support
GuardianPresets.CustomProtectionScenarios.InitializeForDevelopmentWithDebugging("webhook-url");

// Testing environments
GuardianPresets.CustomProtectionScenarios.InitializeForTesting("webhook-url");

// CI/CD pipelines
GuardianPresets.CustomProtectionScenarios.InitializeForCICD();

// Performance-critical applications
GuardianPresets.CustomProtectionScenarios.InitializeForPerformance("webhook-url");

// Web applications
GuardianPresets.CustomProtectionScenarios.InitializeForWebApplications("webhook-url");

// Containerized applications (Docker/Kubernetes)
GuardianPresets.CustomProtectionScenarios.InitializeForContainers("webhook-url");

3. Fluent Builder Pattern

using AgniGuardian;

// Chainable configuration with fluent API
new GuardianBuilder()
    .WithProductionProtection()                    // Enable production-ready settings
    .WithDiscordReporting("webhook-url")           // Attack notifications
    .WithVerboseLogging()                          // Detailed logging
    .WithMonitoringIntervals(60000, 10000)         // Custom intervals
    .WithAdditionalProcessMonitoring("malware")    // Custom process monitoring
    .Initialize();

// NEW: Custom protection with selective disabling
new GuardianBuilder()
    .WithCustomProtection(
        disableAntiDebugger: true,                 // Allow debugging
        disableProcessMonitor: true,               // Don't monitor processes
        disableNetworkGuard: true                  // Allow proxy tools
    )
    .WithDiscordReporting("webhook-url")
    .WithVerboseLogging()
    .Initialize();

// NEW: Quick scenario-based builders
new GuardianBuilder()
    .WithDevelopmentFriendlyProtection()           // Pre-configured for development
    .WithDiscordReporting("webhook-url")
    .Initialize();

new GuardianBuilder()
    .WithTestingProtection()                       // Pre-configured for testing
    .Initialize();

new GuardianBuilder()
    .WithPerformanceOptimizedProtection()          // Pre-configured for performance
    .Initialize();

new GuardianBuilder()
    .WithWebApplicationProtection()                // Pre-configured for web apps
    .WithDiscordReporting("webhook-url")
    .Initialize();

// Or build without initializing for advanced scenarios
var options = new GuardianBuilder()
    .WithBasicProtection()
    .WithDiscordReporting("webhook-url")
    .Build();
Guardian.Initialize(options);

4. ASP.NET Core Integration

using AgniGuardian;

var builder = WebApplication.CreateBuilder(args);

// Method 1: Simple preset-based registration
builder.Services.AddAgniGuardian("Balanced", "discord-webhook-url");

// Method 2: Configuration-based registration
builder.Services.AddAgniGuardian(options =>
{
    options.EnableAntiTamper = true;
    options.EnableProcessMonitor = true;
    options.EnableNetworkGuard = true;
    options.DiscordWebhookUrl = builder.Configuration["AgniGuardian:DiscordWebhookUrl"];
});

var app = builder.Build();

// Add to middleware pipeline
app.UseAgniGuardian();
app.Run();

5. Generic Host / Worker Services Integration

using Microsoft.Extensions.Hosting;
using AgniGuardian;

var host = Host.CreateDefaultBuilder(args)
    .UseAgniGuardian(options =>
    {
        options.EnableAntiTamper = true;
        options.EnableProcessMonitor = true;
        options.EnableVerboseLogging = true;
    })
    .ConfigureServices(services =>
    {
        services.AddHostedService<WorkerService>();
    })
    .Build();

await host.RunAsync();

6. Configuration-Based Integration

JSON Configuration (appsettings.json)

{
  "AgniGuardian": {
    "EnableAntiTamper": true,
    "EnableAntiDebugger": true,
    "EnableAntiPatch": true,
    "EnableAntiInjector": true,
    "EnableAntiDump": true,
    "EnableAntiDecompile": true,
    "EnableIntegrityChecker": true,
    "EnableProcessMonitor": true,
    "EnableRuntimeGuard": true,
    "EnableNetworkGuard": true,
    "DiscordWebhookUrl": "https://discord.com/api/webhooks/your-webhook",
    "EnableVerboseLogging": false,
    "IntegrityCheckIntervalMs": 30000,
    "ProcessMonitorIntervalMs": 5000,
    "AdditionalMonitoredProcesses": ["cheatengine", "ollydbg", "x64dbg"]
  }
}

// Load from appsettings.json
var options = GuardianConfigurationManager.LoadFromAppSettings();
Guardian.Initialize(options);

// Or specify custom file path
var options = GuardianConfigurationManager.LoadFromAppSettings("config/security.json");
Guardian.Initialize(options);

App.config Configuration (.NET Framework)

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="AgniGuardian:EnableAntiTamper" value="true" />
    <add key="AgniGuardian:EnableAntiDebugger" value="true" />
    <add key="AgniGuardian:EnableProcessMonitor" value="true" />
    <add key="AgniGuardian:DiscordWebhookUrl" value="https://discord.com/api/webhooks/your-webhook" />
    <add key="AgniGuardian:IntegrityCheckIntervalMs" value="30000" />
    <add key="AgniGuardian:ProcessMonitorIntervalMs" value="5000" />
    <add key="AgniGuardian:AdditionalMonitoredProcesses" value="cheatengine,ollydbg,x64dbg" />
  </appSettings>
</configuration>

// Load from app.config
var options = GuardianConfigurationManager.LoadFromAppConfig();
Guardian.Initialize(options);

Environment Variables

# Windows Command Prompt
set AGNIGUARDIAN_ENABLE_ANTITAMPER=true
set AGNIGUARDIAN_ENABLE_ANTIDEBUGGER=true
set AGNIGUARDIAN_DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/your-webhook
set AGNIGUARDIAN_INTEGRITY_CHECK_INTERVAL_MS=30000
set AGNIGUARDIAN_ADDITIONAL_MONITORED_PROCESSES=cheatengine,ollydbg

# PowerShell
$env:AGNIGUARDIAN_ENABLE_ANTITAMPER="true"
$env:AGNIGUARDIAN_DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your-webhook"

# Linux/macOS
export AGNIGUARDIAN_ENABLE_ANTITAMPER=true
export AGNIGUARDIAN_DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/your-webhook

// Load from environment variables
var options = GuardianConfigurationManager.LoadFromEnvironmentVariables();
Guardian.Initialize(options);

JSON File Configuration

// Save current configuration to file
var options = new GuardianOptions { /* configure */ };
GuardianConfigurationManager.SaveToJsonFile(options, "agniguardian-config.json");

// Load from JSON file
var options = GuardianConfigurationManager.LoadFromJsonFile("agniguardian-config.json");
Guardian.Initialize(options);

7. Dependency Injection Integration

// Registration in Startup.cs or Program.cs
services.AddAgniGuardian(options =>
{
    options.EnableAntiTamper = true;
    options.EnableProcessMonitor = true;
    options.DiscordWebhookUrl = Configuration["AgniGuardian:DiscordWebhookUrl"];
});

// Usage in controllers or services
public class SecurityController : ControllerBase
{
    private readonly IGuardianService _guardian;
    
    public SecurityController(IGuardianService guardian)
    {
        _guardian = guardian;
    }
    
    public IActionResult GetSecurityStatus()
    {
        return Ok(new { Protected = _guardian.IsInitialized });
    }
}

// Usage in background services
public class SecurityWorker : BackgroundService
{
    private readonly IGuardianService _guardian;
    
    public SecurityWorker(IGuardianService guardian)
    {
        _guardian = guardian;
        _guardian.Initialize();
    }
}

🎯 Application-Specific Integration Examples

Console Applications

using System;
using AgniGuardian;

class Program
{
    static void Main(string[] args)
    {
        // Initialize protection at startup
        GuardianPresets.InitializeBalancedProtection("webhook-url");
        
        try
        {
            // Your application logic here
            Console.WriteLine("Protected console application running...");
            
            // Simulate work
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine($"Processing step {i + 1}...");
                System.Threading.Thread.Sleep(1000);
            }
            
            Console.WriteLine("Application completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Application error: {ex.Message}");
        }
        finally
        {
            // Clean shutdown
            Guardian.Shutdown();
        }
    }
}

WinForms Applications

using System;
using System.Windows.Forms;
using AgniGuardian;

static class Program
{
    [STAThread]
    static void Main()
    {
        // Initialize protection before UI
        new GuardianBuilder()
            .WithFullProtection()
            .WithDiscordReporting("webhook-url")
            .WithVerboseLogging()
            .Initialize();

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        
        // Ensure clean shutdown
        Application.ApplicationExit += (s, e) => Guardian.Shutdown();
        
        Application.Run(new MainForm());
    }
}

// In your main form
public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
        
        // Optional: Add security status to your form
        this.Text += " - Protected by AgniGuardian";
    }
}

WPF Applications

using System.Windows;
using AgniGuardian;

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        // Initialize protection
        GuardianPresets.InitializeMaximumProtection("webhook-url");
        
        base.OnStartup(e);
    }

    protected override void OnExit(ExitEventArgs e)
    {
        // Clean shutdown
        Guardian.Shutdown();
        base.OnExit(e);
    }
}

// In your main window
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        
        // Optional: Show protection status
        Title += " - Protected";
    }
}

ASP.NET Core Web Applications

using AgniGuardian;

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddControllers();
builder.Services.AddAgniGuardian(options =>
{
    options.EnableAntiTamper = true;
    options.EnableNetworkGuard = true;
    options.EnableProcessMonitor = true;
    options.DiscordWebhookUrl = builder.Configuration["AgniGuardian:DiscordWebhookUrl"];
});

var app = builder.Build();

// Configure pipeline
app.UseAgniGuardian();
app.UseRouting();
app.MapControllers();

app.Run();

Blazor Applications

using AgniGuardian;

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
builder.Services.AddAgniGuardian("Enterprise", builder.Configuration["AgniGuardian:DiscordWebhookUrl"]);

var app = builder.Build();

// Configure pipeline
app.UseAgniGuardian();
app.UseStaticFiles();
app.UseRouting();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

app.Run();

Windows Services / Background Services

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.DependencyInjection;
using AgniGuardian;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseWindowsService() // For Windows Service
            .UseAgniGuardian(options =>
            {
                options.EnableAntiTamper = true;
                options.EnableProcessMonitor = true;
                options.EnableVerboseLogging = true;
            })
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
            });
}

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;
    private readonly IGuardianService _guardian;

    public Worker(ILogger<Worker> logger, IGuardianService guardian)
    {
        _logger = logger;
        _guardian = guardian;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _guardian.Initialize();
        
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

Unity Game Engine Integration

using UnityEngine;
using AgniGuardian;

public class GameSecurity : MonoBehaviour
{
    [SerializeField] private string discordWebhookUrl;
    
    void Awake()
    {
        // Initialize gaming-specific protection
        GuardianPresets.InitializeGamingProtection(discordWebhookUrl);
        
        // Ensure AgniGuardian persists across scenes
        DontDestroyOnLoad(gameObject);
    }
    
    void OnApplicationPause(bool pauseStatus)
    {
        // Handle mobile app lifecycle
        if (pauseStatus)
        {
            // App is pausing - maintain protection
        }
    }
    
    void OnApplicationQuit()
    {
        // Clean shutdown
        Guardian.Shutdown();
    }
}

Xamarin / MAUI Applications

using AgniGuardian;

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
        
        // Initialize with lightweight protection for mobile
        GuardianPresets.InitializeLightweightProtection();
        
        MainPage = new AppShell();
    }
    
    protected override void OnSleep()
    {
        // App is going to sleep - maintain protection
        base.OnSleep();
    }
    
    protected override void OnResume()
    {
        // App is resuming - ensure protection is active
        base.OnResume();
    }
}

🎛️ Custom Protection Configuration

NEW: Selective Protection Disabling

using AgniGuardian;

// Disable specific protections while keeping others active
GuardianPresets.InitializeCustomProtection(
    discordWebhookUrl: "https://discord.com/api/webhooks/your-webhook",
    
    // Core Protection Modules (disable as needed)
    disableAntiTamper: false,         // Keep tamper protection
    disableAntiDebugger: true,        // Allow debugging
    disableAntiPatch: false,          // Keep patch protection
    disableAntiInjector: false,       // Keep injection protection
    disableAntiDump: false,           // Keep dump protection
    disableAntiDecompile: true,       // Allow decompilation for debugging
    
    // Advanced Monitoring (disable as needed)
    disableIntegrityChecker: true,    // Disable file monitoring
    disableProcessMonitor: true,      // Don't monitor processes
    disableRuntimeGuard: true,        // Allow reflection debugging
    disableNetworkGuard: true,        // Allow proxy tools
    
    // Configuration
    enableVerboseLogging: true,       // Enable detailed logging
    integrityCheckIntervalMs: 120000, // Custom interval (2 minutes)
    processMonitorIntervalMs: 20000,  // Custom interval (20 seconds)
    additionalMonitoredProcesses: new[] { "custom_threat", "malware" }
);

Common Custom Scenarios

// Scenario 1: Development Environment
GuardianPresets.InitializeCustomProtection(
    disableAntiDebugger: true,        // Allow Visual Studio debugger
    disableAntiDecompile: true,       // Allow decompilation tools
    disableProcessMonitor: true,      // Don't interfere with dev tools
    disableNetworkGuard: true,        // Allow Fiddler, Postman, etc.
    enableVerboseLogging: true
);

// Scenario 2: Testing Environment
GuardianPresets.InitializeCustomProtection(
    disableAntiDebugger: true,        // Allow test debugging
    disableRuntimeGuard: true,        // Allow reflection in tests
    enableVerboseLogging: true,
    integrityCheckIntervalMs: 300000  // Less frequent checks
);

// Scenario 3: Performance-Critical Production
GuardianPresets.InitializeCustomProtection(
    disableIntegrityChecker: true,    // Reduce I/O overhead
    disableProcessMonitor: true,      // Reduce CPU overhead
    processMonitorIntervalMs: 60000   // Very infrequent monitoring
);

// Scenario 4: Web API Applications
GuardianPresets.InitializeCustomProtection(
    disableAntiDecompile: true,       // Not needed for web APIs
    disableIntegrityChecker: true,    // Files don't change in containers
    disableProcessMonitor: true,      // Container isolation handles this
    disableNetworkGuard: false        // Keep network protection for APIs
);

// Scenario 5: Desktop Applications with User Tools
GuardianPresets.InitializeCustomProtection(
    disableProcessMonitor: true,      // Don't interfere with user's tools
    disableNetworkGuard: true,        // Allow user's proxy/VPN
    enableVerboseLogging: false,      // Keep logs minimal for users
    integrityCheckIntervalMs: 180000  // Less frequent checks
);

Protection Module Reference

// Available protection modules to disable:

disableAntiTamper: false,         // Method integrity verification
disableAntiDebugger: false,       // Debugger detection (x64dbg, dnSpy, VS)
disableAntiPatch: false,          // IL byte change detection
disableAntiInjector: false,       // DLL injection detection
disableAntiDump: false,           // Memory dumping prevention
disableAntiDecompile: false,      // Decompilation protection
disableIntegrityChecker: false,   // File system monitoring
disableProcessMonitor: false,     // Malicious process detection
disableRuntimeGuard: false,       // Reflection/profiler monitoring
disableNetworkGuard: false        // SSL pinning/proxy detection

🔧 Advanced Configuration

Custom Protection Profile

var options = new GuardianOptions
{
    // Core Protection Modules
    EnableAntiTamper = true,
    EnableAntiDebugger = true,
    EnableAntiPatch = true,
    EnableAntiInjector = true,
    EnableAntiDump = true,
    EnableAntiDecompile = true,
    
    // Advanced Monitoring
    EnableIntegrityChecker = true,
    EnableProcessMonitor = true,
    EnableRuntimeGuard = true,
    EnableNetworkGuard = true,
    
    // Logging and Reporting
    EnableVerboseLogging = true,
    DiscordWebhookUrl = "https://discord.com/api/webhooks/your-webhook-url",
    
    // Performance Tuning
    IntegrityCheckIntervalMs = 30000,  // 30 seconds
    ProcessMonitorIntervalMs = 5000,   // 5 seconds
    
    // Custom Process Monitoring
    AdditionalMonitoredProcesses = new[] { "suspicious_app", "malware" }
};

Guardian.Initialize(options);

Network Security

// SSL Certificate Pinning
NetworkGuard.AddPinnedCertificate("SHA1_THUMBPRINT");
NetworkGuard.AddPinnedPublicKey("BASE64_PUBLIC_KEY");

// Trusted IP Ranges
NetworkGuard.AddTrustedIpRange("192.168.1.1", "192.168.1.255");

// Secure HTTP Client
using var httpClient = NetworkGuard.CreateSecureHttpClient();

🛠️ Development vs Production Integration

Environment-Based Configuration

using System;
using System.Diagnostics;
using AgniGuardian;

public static class SecurityManager
{
    public static void Initialize()
    {
        #if DEBUG
            // Development mode - allows debugging and dev tools
            GuardianPresets.InitializeDevelopmentProtection();
            Console.WriteLine("AgniGuardian: Development mode active");
        #else
            // Production mode - full protection
            var webhookUrl = Environment.GetEnvironmentVariable("DISCORD_WEBHOOK_URL");
            GuardianPresets.InitializeMaximumProtection(webhookUrl);
            Console.WriteLine("AgniGuardian: Production mode active");
        #endif
    }
}

Runtime Environment Detection

using AgniGuardian;

public static void InitializeBasedOnEnvironment()
{
    var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") 
                     ?? Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT")
                     ?? "Production";

    switch (environment.ToLower())
    {
        case "development":
            GuardianPresets.InitializeDevelopmentProtection();
            break;
        case "staging":
            GuardianPresets.InitializeBalancedProtection();
            break;
        case "production":
            GuardianPresets.InitializeMaximumProtection("webhook-url");
            break;
        default:
            GuardianPresets.InitializeBalancedProtection();
            break;
    }
}

Conditional Protection Based on Runtime Conditions

using System.Diagnostics;
using AgniGuardian;

new GuardianBuilder()
    .WithProtections(
        antiTamper: true,                                    // Always enabled
        antiDebugger: !Debugger.IsAttached,                 // Disable if debugger attached
        antiPatch: true,                                     // Always enabled
        antiInjector: true,                                  // Always enabled
        antiDump: true,                                      // Always enabled
        antiDecompile: true,                                 // Always enabled
        integrityChecker: !IsRunningInIDE(),                 // Disable in IDE
        processMonitor: IsProductionEnvironment(),           // Only in production
        runtimeGuard: !IsDebuggingSession(),                 // Disable during debugging
        networkGuard: IsProductionEnvironment()              // Only in production
    )
    .WithVerboseLogging(IsDevelopmentEnvironment())
    .WithDiscordReporting(GetWebhookUrlForEnvironment())
    .Initialize();

static bool IsRunningInIDE()
{
    return Debugger.IsAttached || 
           Environment.GetEnvironmentVariable("TERM_PROGRAM") == "vscode" ||
           Process.GetCurrentProcess().ProcessName.Contains("devenv");
}

static bool IsProductionEnvironment()
{
    return Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production";
}

static bool IsDevelopmentEnvironment()
{
    return Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development";
}

static bool IsDebuggingSession()
{
    return Debugger.IsAttached || IsDevelopmentEnvironment();
}

static string GetWebhookUrlForEnvironment()
{
    var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
    return env switch
    {
        "Production" => Environment.GetEnvironmentVariable("PROD_DISCORD_WEBHOOK"),
        "Staging" => Environment.GetEnvironmentVariable("STAGING_DISCORD_WEBHOOK"),
        _ => null
    };
}

Configuration File Based on Environment

using AgniGuardian;

public static void InitializeFromConfig()
{
    var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production";
    var configFile = $"appsettings.{environment.ToLower()}.json";
    
    GuardianOptions options;
    
    if (File.Exists(configFile))
    {
        options = GuardianConfigurationManager.LoadFromAppSettings(configFile);
    }
    else
    {
        // Fallback to default configuration
        options = GuardianConfigurationManager.LoadFromAppSettings();
    }
    
    Guardian.Initialize(options);
}

Docker Container Integration

# Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# Set environment variables for AgniGuardian
ENV AGNIGUARDIAN_ENABLE_ANTITAMPER=true
ENV AGNIGUARDIAN_ENABLE_NETWORKGUARD=true
ENV AGNIGUARDIAN_DISCORD_WEBHOOK_URL=${DISCORD_WEBHOOK_URL}

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore "MyApp.csproj"
COPY . .
RUN dotnet build "MyApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

// In your application
public static void Main(string[] args)
{
    // Load configuration from environment variables (Docker-friendly)
    var options = GuardianConfigurationManager.LoadFromEnvironmentVariables();
    Guardian.Initialize(options);
    
    CreateHostBuilder(args).Build().Run();
}

CI/CD Pipeline Integration

# Azure DevOps Pipeline
- task: DotNetCoreCLI@2
  displayName: 'Build with AgniGuardian Protection'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration Release'
  env:
    AGNIGUARDIAN_ENABLE_ANTITAMPER: 'true'
    AGNIGUARDIAN_DISCORD_WEBHOOK_URL: $(DISCORD_WEBHOOK_URL)

# GitHub Actions
- name: Build with Protection
  run: dotnet build --configuration Release
  env:
    AGNIGUARDIAN_ENABLE_ANTITAMPER: true
    AGNIGUARDIAN_DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}

📚 Complete Integration Guide

For comprehensive integration examples, configuration options, and troubleshooting, see:

• INTEGRATION_GUIDE.md - Complete integration documentation
• AgniGuardian-WinForms-Samples - Working examples

🎯 Integration Benefits & Features

✅ Zero Configuration Required

• Works immediately with Guardian.Initialize()
• No setup files or complex configuration needed
• Intelligent defaults for all protection modules

✅ Multiple Integration Patterns

• One-Line: Guardian.Initialize() - Instant protection
• Preset-Based: 7 predefined configurations for different scenarios
• Custom Protection: Selectively disable specific protections with simple parameters
• Scenario-Based: Pre-configured custom scenarios for common use cases
• Fluent Builder: Chainable API with custom protection methods
• Dependency Injection: Full DI container support
• Configuration Files: JSON, XML, environment variables
• Framework-Specific: ASP.NET Core, WinForms, WPF, Console, etc.

✅ Framework Agnostic

• .NET Framework 4.6.2+ to .NET 8.0+
• Console, WinForms, WPF, ASP.NET Core, Blazor
• Windows Services, Background Services, Unity, Xamarin/MAUI
• Cross-platform compatibility with Windows-optimized features

✅ Production Ready

• Comprehensive logging with structured events
• Real-time attack reporting via Discord webhooks
• Performance-optimized with configurable monitoring intervals
• Graceful degradation and error handling

✅ Developer Friendly

• Special development mode that allows debugging
• Conditional compilation support for dev vs production
• Extensive documentation and working examples
• IntelliSense support with comprehensive XML documentation

✅ Highly Configurable

• Fine-tune every aspect of protection
• 10+ protection modules with individual enable/disable
• NEW: Selective protection disabling with simple boolean parameters
• NEW: Pre-configured scenarios for common use cases (development, testing, performance, web apps, containers)
• Custom monitoring intervals and process lists
• Multiple configuration sources with precedence handling

✅ Enterprise Features

• Multi-environment support (Dev/Staging/Production)
• Docker and CI/CD pipeline integration
• Centralized configuration management
• Audit logging and compliance reporting

✅ Gaming & Anti-Cheat Optimized

• Specialized gaming preset with aggressive monitoring
• 100+ malicious process signatures including cheat engines
• Real-time memory protection and injection detection
• Low-latency monitoring for competitive gaming

✅ Security Best Practices

• Multi-layered protection approach
• Real-time threat detection and response
• SSL certificate pinning and network security
• Comprehensive attack surface coverage

� Quickr Start Recommendations

For New Users (Recommended Path)

1. Start Simple: Use Guardian.Initialize() for immediate protection
2. Choose Preset: Move to GuardianPresets.InitializeBalancedProtection()
3. Add Reporting: Include Discord webhook for attack notifications
4. Customize: Use GuardianBuilder for specific requirements
5. Production: Implement environment-specific configurations

For Different Application Types

• Console Apps: Use GuardianPresets.InitializeBalancedProtection()
• Desktop Apps: Use GuardianPresets.InitializeMaximumProtection()
• Web Apps: Use GuardianPresets.CustomProtectionScenarios.InitializeForWebApplications()
• Games: Use GuardianPresets.InitializeGamingProtection()
• Enterprise: Use GuardianPresets.InitializeEnterpriseProtection()
• Development: Use GuardianPresets.CustomProtectionScenarios.InitializeForDevelopmentWithDebugging()
• Testing: Use GuardianPresets.CustomProtectionScenarios.InitializeForTesting()
• CI/CD: Use GuardianPresets.CustomProtectionScenarios.InitializeForCICD()
• Containers: Use GuardianPresets.CustomProtectionScenarios.InitializeForContainers()
• Custom Needs: Use GuardianPresets.InitializeCustomProtection() with selective disabling

Performance Considerations

• High Performance: Use GuardianPresets.InitializeLightweightProtection()
• Balanced: Use GuardianPresets.InitializeBalancedProtection()
• Maximum Security: Use GuardianPresets.InitializeMaximumProtection()

📚 Complete Documentation

Integration Resources

• INTEGRATION_GUIDE.md - Comprehensive integration documentation
• AgniGuardian-WinForms-Samples - Working examples
• XML Documentation - IntelliSense support in your IDE

Configuration Examples

• JSON Configuration: Complete appsettings.json examples
• Environment Variables: Docker and CI/CD friendly setup
• Dependency Injection: ASP.NET Core and Generic Host integration
• Multi-Environment: Development, staging, and production configurations

📞 Support & Community

• 📖 Documentation: Complete integration guide and API reference included
• 💡 Examples: Multiple working samples for different application types
• 🐛 Issues: Report bugs and feature requests on GitHub repository
• 💬 Community: Discord server for discussions and support
• 📧 Enterprise: Contact for enterprise support and custom integrations

🔄 Migration Guide

From Manual Security Implementation

// Before: Manual security checks
if (Debugger.IsAttached) Environment.Exit(1);
// ... hundreds of lines of security code

// After: One line with AgniGuardian
Guardian.Initialize();

From Other Security Libraries

// Replace your existing security library initialization
// OtherSecurityLib.Initialize();

// With AgniGuardian
GuardianPresets.InitializeMaximumProtection("webhook-url");

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.