C# (ASP.NET Core)

Para entornos empresariales de Microsoft, integrar ProxyTracer directamente en la canalización de solicitudes HTTP de ASP.NET Core garantiza que el tráfico malicioso sea rechazado antes de que active el enrutamiento, el enlace de modelos o consultas a bases de datos.

El Middleware

Esta implementación utiliza System.Text.Json para una deserialización ultra rápida, impone un estricto límite de timeout a través de HttpClient e interrumpe la canalización con una respuesta 403 Forbidden si detecta riesgo.


using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
 
namespace ProxyTracer.Security
{
    public class ProxyTracerMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly HttpClient _httpClient;
        private readonly ILogger<ProxyTracerMiddleware> _logger;
        private readonly string _apiKey;
 
        public ProxyTracerMiddleware(RequestDelegate next, IConfiguration config, ILogger<ProxyTracerMiddleware> logger)
        {
            _next = next;
            _logger = logger;
            _apiKey = config["PROXYTRACER_API_KEY"] ?? throw new ArgumentNullException("PROXYTRACER_API_KEY is missing");
            
            // Cliente reutilizable con un timeout estricto de 500 ms
            _httpClient = new HttpClient { Timeout = TimeSpan.FromMilliseconds(500) };
        }
 
        public async Task InvokeAsync(HttpContext context)
        {
            // 1. Extraer la IP (Requiere app.UseForwardedHeaders() configurado en Program.cs)
            var ip = context.Connection.RemoteIpAddress?.ToString();
 
            // Omitir las IPs de desarrollo local
            if (!string.IsNullOrEmpty(ip) && ip != "127.0.0.1" && ip != "::1")
            {
                try
                {
                    // 2. Consultar la API de ProxyTracer de forma asíncrona
                    using var request = new HttpRequestMessage(HttpMethod.Get, $"https://api.proxytracer.com/v1/check/{ip}");
                    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
 
                    using var response = await _httpClient.SendAsync(request);
 
                    if (response.IsSuccessStatusCode)
                    {
                        using var jsonStream = await response.Content.ReadAsStreamAsync();
                        var ptResponse = await JsonSerializer.DeserializeAsync<ProxyTracerResult>(jsonStream);
 
                        // 3. Descartar la conexión si se detecta un proxy/VPN
                        if (ptResponse != null && ptResponse.Proxy)
                        {
                            context.Response.StatusCode = StatusCodes.Status403Forbidden;
                            context.Response.ContentType = "application/json";
                            await context.Response.WriteAsync("{\"error\": \"Access Denied: VPN or Proxy detected.\"}");
                            return; // Interrumpe la tubería de peticiones (short-circuit)
                        }
                    }
                }
                catch (Exception ex)
                {
                    // Fail open: Registrar el error y permitir el paso de la solicitud
                    _logger.LogWarning($"ProxyTracer validation failed: {ex.Message}");
                }
            }
 
            // 4. El tráfico está limpio, continuar hacia los controladores
            await _next(context);
        }
 
        // Estructura ligera que mapea exactamente a la respuesta {"proxy": true|false}
        private class ProxyTracerResult
        {
            [JsonPropertyName("proxy")]
            public bool Proxy { get; set; }
        }
    }
}

Configuración:

Para activar la protección, registra el middleware en tu archivo Program.cs. Asegúrate de colocarlo después de UseForwardedHeaders pero antes de UseRouting y UseAuthentication.


var app = builder.Build();
 
// 1. Asegúrese de que se extraigan las IP reales si se encuentra detrás de un balanceador de carga NGINX/Cloudflare
app.UseForwardedHeaders();
 
// 2. Descartar el tráfico malicioso temprano
app.UseMiddleware<ProxyTracer.Security.ProxyTracerMiddleware>();
 
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
 
app.Run();