‫اسکن بدافزارها در حین آپلود فایل‌ها در ASP.NET Core با استفاده از Windows AMSI: آخرین خط دفاعی

• فایل PDF قانونی حاوی سوءاستفاده‌های جاسازی‌شده جاوااسکریپت.
• سند آفیس معتبر حاوی ماکروهای مخرب (Macro-based Malware).
• فایل تصویری واقعی با بارگذاری‌های (Payloads) جاسازی‌شده از طریق نهان‌نگاری (Steganography).
• بایگانی‌های (Archive) واقعی حاوی بدافزار.
• حملات روز صفر (Zero-day) که کتابخانه‌های پردازش فایل را هدف قرار می‌دهند.

• انحصاری برای ویندوز: AMSI فقط در سیستم‌عامل ویندوز قابل استفاده است. (برای نیازهای کراس‌پلتفرم، می‌توان ClamAV یا سرویس‌های ابری را در نظر گرفت).
• نیاز به آنتی‌ویروس سازگار: نصب بودن یک موتور آنتی‌ویروس سازگار با AMSI ضروری است.
• غیرقابل نفوذ نبودن: مانند هر راهکار آنتی‌ویروس، توانایی تشخیص تهدیدات روز صفر کاملاً ناشناخته را ندارد.

public sealed class MalwareScanValidationStep
{
    private readonly ILogger _logger;

    public MalwareScanValidationStep(ILogger logger)
    {
        _logger = logger;
    }

    public async Task<ValidationResult> ValidateAsync(IFormFile file, CancellationToken token)
    {
        // فرض کنید متد GetData() یک متد Extension برای خواندن محتوای IFormFile به صورت آرایه بایت است.
        var payload = await file.GetData(); 
        
        // 1. ایجاد یک Context جدید AMSI
        using var application = AmsiContext.Create("DocumentStorage"); 
        
        // 2. ایجاد یک Session جدید (برای مرتبط کردن درخواست‌های اسکن)
        using var session = application.CreateSession(); 
        
        // 3. اسکن محتوای فایل
        var isMalware = await session.IsPotentialMalwareAsync(payload, file.Name, token);
        
        if (isMalware)
        {
            _logger.LogWarning("MalwareScan: File '{FileName}' potentially contains malware.", file.FileName);
            // در صورت تشخیص بدافزار، عملیات را با خطا متوقف می‌کنیم.
            return ValidationResult.Fail(new BadRequestObjectResult(new { message = "Document potentially contains malware." }));
        }

        return ValidationResult.Success();
    }
}

public sealed class AmsiContext : IDisposable
{
    private IntPtr _handle;

    private AmsiContext(IntPtr handle)
    {
        _handle = handle;
    }

    public static AmsiContext Create(string appName)
    {
        var result = AmsiInitialize(appName, out var handle);
        if (result != 0)
        {
            throw new InvalidOperationException($"Failed to initialize AMSI. Error code: {result}");
        }
        return new AmsiContext(handle);
    }

    public AmsiSession CreateSession()
    {
        var result = AmsiOpenSession(_handle, out var sessionHandle);
        if (result != 0)
        {
            throw new InvalidOperationException($"Failed to open AMSI session. Error code: {result}");
        }
        return new AmsiSession(_handle, sessionHandle);
    }

    public void Dispose()
    {
        if (_handle != IntPtr.Zero)
        {
            AmsiUninitialize(_handle);
            _handle = IntPtr.Zero;
        }
    }

    [DllImport("amsi.dll", CharSet = CharSet.Unicode)]
    private static extern int AmsiInitialize(string appName, out IntPtr amsiContext);

    [DllImport("amsi.dll")]
    private static extern int AmsiOpenSession(IntPtr amsiContext, out IntPtr session);

    [DllImport("amsi.dll")]
    private static extern void AmsiUninitialize(IntPtr amsiContext);
}

public sealed class AmsiSession : IDisposable
{
    private readonly IntPtr _amsiContext;
    private IntPtr _sessionHandle;

    internal AmsiSession(IntPtr amsiContext, IntPtr sessionHandle)
    {
        _amsiContext = amsiContext;
        _sessionHandle = sessionHandle;
    }

    public async Task<bool> IsPotentialMalwareAsync(byte[] data, string filename, CancellationToken cancellationToken = default)
    {
        return await Task.Run(() => IsPotentialMalware(data, filename), cancellationToken);
    }

    private bool IsPotentialMalware(byte[] data, string filename)
    {
        var result = AmsiScanBuffer(_amsiContext, data, (uint)data.Length, filename, _sessionHandle, out var scanResult);
        if (result != 0)
        {
            throw new InvalidOperationException($"Failed to scan buffer. Error code: {result}");
        }

        // AMSI_RESULT values:
        // 0 = Clean
        // 1-32767 = Detected (higher = more confident detection)
        // 32768+ = Blocked
        return scanResult >= 1;
    }

    public void Dispose()
    {
        if (_sessionHandle != IntPtr.Zero)
        {
            AmsiCloseSession(_amsiContext, _sessionHandle);
            _sessionHandle = IntPtr.Zero;
        }
    }

    [DllImport("amsi.dll")]
    private static extern int AmsiScanBuffer(IntPtr amsiContext, byte[] buffer, uint length, string contentName, IntPtr session, out int result);

    [DllImport("amsi.dll")]
    private static extern void AmsiCloseSession(IntPtr amsiContext, IntPtr session);
}

[Test]
public async Task ValidateAsync_WithEICARTestFile_ReturnsFail()
{
    // EICAR test string - universally detected as malware
    const string eicarString = @"X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*";
    var eicarBytes = Encoding.UTF8.GetBytes(eicarString);
    
    var mockFile = new Mock<IFormFile>();
    mockFile.Setup(f => f.FileName).Returns("eicar.txt");
    
    // Mock GetData() extension method
    var memoryStream = new MemoryStream(eicarBytes);
    mockFile.Setup(f => f.OpenReadStream()).Returns(memoryStream);
    mockFile.Setup(f => f.Length).Returns(eicarBytes.Length);
    
    var validator = new MalwareScanValidationStep(logger);
    
    // Act
    var result = await validator.ValidateAsync(mockFile.Object, CancellationToken.None);
    
    // Assert
    Assert.That(result.IsValid, Is.False);
    Assert.That(result.ErrorResult, Is.InstanceOf<BadRequestObjectResult>());
}