HTTP.sys implementación del servidor web en ASP.NET Core

Note

Esta no es la versión más reciente de este artículo. Para obtener la versión actual, consulte la versión .NET 11 de este artículo.

Por Tom Dykstra y Chris Ross

HTTP.sys es un servidor web para ASP.NET Core que solo se ejecuta en Windows. HTTP.sys supone una alternativa al servidor Kestrel y ofrece algunas características que Kestrel no facilita. En este artículo se explica cuándo usar HTTP.sys, cómo configurarlo y cómo inspeccionar la información de solicitud y TLS.

Important

HTTP.sys no es compatible con el módulo ASP.NET Core y no se puede usar con IIS o IIS Express.

HTTP.sys admite las siguientes características:

  • Autenticación de Windows
  • Uso compartido de puertos
  • HTTPS con SNI
  • HTTP/2 a través de TLS (Windows 10 o posterior)
  • HTTP/3 a través de TLS (Windows 11 o posterior)
  • Transmisión directa de archivos
  • Almacenamiento en caché de respuesta
  • WebSockets (Windows 8 o posterior)
  • Descriptores de seguridad personalizables
  • Expulsión automática del grupo de memoria

El sistema operativo debe ser compatible con la versión de destino de la aplicación de .NET. Para ver las versiones de Windows compatibles, consulte Instalación de .NET en Windows. La disponibilidad de HTTP.sys en versiones anteriores de Windows no implica que las versiones actuales de ASP.NET Core sean compatibles con esas versiones. Las características individuales pueden tener requisitos adicionales de Windows, como se describe en las secciones siguientes.

Ver o descargar código de ejemplo (cómo descargar)

Cuándo usar HTTP.sys

HTTP.sys resulta útil para implementaciones en las que:

  • Es necesario exponer el servidor directamente a Internet sin usar IIS.

    HTTP.sys se comunica directamente con Internet

  • Una implementación interna requiere una característica que no está disponible en Kestrel. Para obtener más información, vea Diferencias entre Kestrel y HTTP.sys.

    HTTP.sys se comunica directamente con la red interna

HTTP.sys es una tecnología consolidada que protege contra muchos tipos de ataques y que proporciona la solidez, la seguridad y la escalabilidad de un servidor web con todas las características. El propio IIS se ejecuta como agente de escucha de HTTP sobre HTTP.sys.

Compatibilidad con HTTP/2

HTTP/2 está habilitado para ASP.NET Core aplicaciones cuando se cumplen los siguientes requisitos base:

Si se establece una conexión HTTP/2, HttpRequest.Protocol notifica HTTP/2.

HTTP/2 está habilitado de forma predeterminada. Si no se establece una conexión HTTP/2, la conexión vuelve a HTTP/1.1. En Windows versiones que lo admiten, la disablehttp2 opción en un netsh http enlace de certificado SSL deshabilita HTTP/2 para ese enlace. Para ver las opciones disponibles, consulte netsh http.

Compatibilidad con HTTP/3

HTTP/3 está habilitado para ASP.NET Core aplicaciones cuando se cumplen los siguientes requisitos base:

Las versiones anteriores de compilación de Windows 11 pueden requerir el uso de una compilación Windows Insider.

HTTP/3 se detecta como una actualización de HTTP/1.1 o HTTP/2 por medio del encabezado alt-svc. Esto significa que la primera solicitud normalmente usará HTTP/1.1 o HTTP/2 antes de cambiar a HTTP/3. Http.Sys no agrega automáticamente el encabezado alt-svc; debe agregarlo la aplicación. El código siguiente es un ejemplo de middleware que agrega el encabezado de respuesta alt-svc.

app.Use((context, next) =>
{
    context.Response.Headers.AltSvc = "h3=\":443\"";
    return next(context);
});

Coloque el código anterior al principio de la canalización de solicitud.

Http.Sys también admite el envío de un mensaje de protocolo HTTP/2 AltSvc en lugar de un encabezado de respuesta para notificar al cliente que HTTP/3 está disponible. Vea la clave del Registro EnableAltSvc.

Note

Para esto se necesitan enlaces sslcert de netsh que usen nombres de host en lugar de direcciones IP. Reemplace ipport por hostnameport en los comandos netsh http add sslcert siguientes, y reemplace la dirección IP por el nombre de host, por ejemplo, www.example.com. También hay un problema conocido por el que se produce un error al usar hostnameport , a menos que se especifique el certstorename parámetro . De forma predeterminada, use certstorename=MY.

Autenticación de modo kernel con Kerberos

HTTP.sys delega la autenticación en modo kernel usando el protocolo de autenticación Kerberos. La autenticación de modo usuario no se admite con Kerberos y HTTP.sys. La cuenta del equipo debe usarse para descifrar el token o vale de Kerberos obtenido de Active Directory y reenviado por el cliente al servidor para autenticar al usuario. Registre el Nombre Principal de Servicio (SPN) para el host, no para el usuario de la aplicación.

Habilitar la protección del token de enlace de canal (CBT)

Los tokens de enlace de canal (CBT) vinculan la autenticación de Windows al canal TLS subyacente, lo que ayuda a mitigar los ataques de retransmisión NTLM y de intermediario.

Configure la protección de CBT con HttpAuthenticationHardeningLevel. Los valores disponibles HttpAuthenticationHardeningLevel son:

Value Behavior
Legacy No aplica la validación del enlace de canal ni expone bytes CBT a la aplicación.
Medium (valor predeterminado) Valida los CBT cuando los clientes los suministran, pero permite su ausencia. Expone bytes CBT a la aplicación.
Strict Requiere CBT en solicitudes autenticadas y rechaza las solicitudes sin ellas. Expone bytes CBT a la aplicación.

En el ejemplo siguiente se habilita la protección Strict:

builder.WebHost.UseHttpSys(options =>
{
    options.HttpAuthenticationHardeningLevel =
        HttpAuthenticationHardeningLevel.Strict;
});

Si HTTP.sys no puede aplicar el refuerzo de Strict, se produce un error en el inicio del servidor con un HttpSysException. Con Legacy o Medium, se registra un error al no poder aplicar la configuración y el inicio continúa. El valor configurado por sí solo no garantiza que el sistema operativo aplique la configuración.

Warning

Strict el refuerzo puede hacer que autenticación de Windows falle para los clientes o servidores proxy que no proporcionan un CBT válido. Pruebe la compatibilidad del cliente y la terminación TLS en el entorno antes de habilitarla en producción.

Al conectarse a una cola de solicitudes existente, configure la protección en el agente de escucha propietario del grupo de direcciones URL. La aplicación que se adjunta no aplica la configuración del grupo de direcciones URL.

Para obtener acceso a bytes CBT, consulte Obtención de tokens de enlace de canal.

Habilite el refuerzo de CBT para los puntos de conexión HTTPS que usan autenticación de Windows estableciendo el Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening modificador AppContext en true. Este modificador selecciona la protección media, que valida los CBT suministrados, pero permite su ausencia.

Habilite el interruptor en el archivo de su proyecto runtimeconfig.template.json.

{
  "configProperties": {
    "Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening": true
  }
}

Como alternativa, establezca el modificador mediante programación antes de compilar el host en el Program archivo:

AppContext.SetSwitch("Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening", true);

Warning

La protección de está desactivada de forma predeterminada. Habilitarlo puede provocar un fallo en la autenticación de Windows para los clientes o servidores proxy que no admiten la vinculación de canal. Pruebe exhaustivamente en el entorno antes de habilitar en producción.

Compatibilidad con la bufferización de respuestas en modo kernel

En algunos escenarios, grandes volúmenes de escrituras pequeñas con latencia alta pueden causar un impacto significativo en el rendimiento de HTTP.sys. Este impacto se debe a la falta de un búfer de Pipe en la implementación de HTTP.sys. Para mejorar el rendimiento en estos escenarios, se ha agregado compatibilidad con el almacenamiento en búfer de respuesta a HTTP.sys. Habilite el almacenamiento en búfer estableciendo EnableKernelResponseBuffering en true. Una aplicación que realiza E/S sincrónica debe habilitar el almacenamiento en búfer de respuesta, o una que realiza E/S asincrónica, pero sin más de una escritura pendiente a la vez. En estos escenarios, el almacenamiento en búfer de respuesta puede mejorar significativamente el rendimiento en las conexiones de alta latencia.

Las aplicaciones que usan E/S asincrónica y que pueden tener más de una escritura pendiente a la vez no deben usar esta marca. Habilitar esta marca puede dar lugar a que HTTP.Sys use más CPU y memoria.

Cómo usar HTTP.sys

Configuración de la aplicación de ASP.NET Core para usar HTTP.sys

Llame al método de extensión UseHttpSys al configurar el host, especificando cualquier opción HttpSysOptions requerida. En el siguiente ejemplo se establecen las opciones en sus valores predeterminados:

using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys(options =>
{
    options.AllowSynchronousIO = false;
    options.Authentication.Schemes = AuthenticationSchemes.None;
    options.Authentication.AllowAnonymous = true;
    options.MaxConnections = null;
    options.MaxRequestBodySize = 30_000_000;
    options.UrlPrefixes.Add("http://localhost:5005");
});

builder.Services.AddRazorPages();

var app = builder.Build();

La configuración adicional de HTTP.sys se controla a través de Configuración del Registro.

Para obtener más información acerca de las opciones de HTTP.sys, consulte HttpSysOptions.

Personalización de descriptores de seguridad

Una cola de solicitudes en HTTP.sys es una estructura de nivel de kernel que almacena temporalmente las solicitudes HTTP entrantes hasta que la aplicación esté lista para procesarlas. Administre el acceso a la cola de solicitudes mediante RequestQueueSecurityDescriptor. Al configurar el servidor de HTTP.sys, establézcalo en una instancia GenericSecurityDescriptor.

Al personalizar el descriptor de seguridad, puede permitir o denegar el acceso de usuarios o grupos específicos a la cola de solicitudes. Esto es útil en escenarios en los cuales desea restringir o delegar la gestión de solicitudes HTTP.sys a nivel del sistema operativo.

Por ejemplo, el código siguiente permite a todos los usuarios autenticados, pero deniega a los invitados:

using System.Security.AccessControl;
using System.Security.Principal;
using Microsoft.AspNetCore.Server.HttpSys;

// Create a new security descriptor
var securityDescriptor = new CommonSecurityDescriptor(isContainer: false, isDS: false, sddlForm: string.Empty);

// Create a discretionary access control list (DACL)
var dacl = new DiscretionaryAcl(isContainer: false, isDS: false, capacity: 2);
dacl.AddAccess(
    AccessControlType.Allow,
    new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null),
    -1,
    InheritanceFlags.None,
    PropagationFlags.None
);
dacl.AddAccess(
    AccessControlType.Deny,
    new SecurityIdentifier(WellKnownSidType.BuiltinGuestsSid, null),
    -1,
    InheritanceFlags.None,
    PropagationFlags.None
);

// Assign the DACL to the security descriptor
securityDescriptor.DiscretionaryAcl = dacl;

// Configure HTTP.sys options
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseHttpSys(options =>
{
    options.RequestQueueSecurityDescriptor = securityDescriptor;
});

La RequestQueueSecurityDescriptor propiedad solo se aplica al crear una nueva cola de solicitudes. La propiedad no afecta a las colas de solicitudes existentes. Cuando RequestQueueMode se Attachabre una cola existente, las opciones de nivel de cola, como RequestQueueSecurityDescriptor y RequestQueueLimit no se aplican. En Attach modo, la configuración del grupo de direcciones URL, como los tiempos de espera y la protección de autenticación, debe configurarse mediante el agente de escucha que posee el grupo de direcciones URL y UrlPrefixes solo se usa para calcular PathBase. CreateOrAttach sigue configurando su propio grupo de direcciones URL y registra su UrlPrefixes, incluso cuando la cola ya existe; los valores de los prefijos ya registrados por otro agente de escucha permanecen controlados por ese agente de escucha.

MaxRequestBodySize

Tamaño máximo permitido de cualquier cuerpo de solicitud en bytes. Cuando se establece en null, el tamaño máximo del cuerpo de solicitud es ilimitado. Este límite no tiene ningún efecto en las conexiones actualizadas, que siempre son ilimitadas.

El método recomendado para invalidar el límite en una aplicación de ASP.NET Core MVC para una sola IActionResult es usar el atributo RequestSizeLimitAttribute en un método de acción:

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

Se lanza una excepción si la aplicación intenta configurar el límite de una solicitud después de que haya comenzado a leerla. Puede usarse una propiedad IsReadOnly que indique si la propiedad MaxRequestBodySize tiene el estado de solo lectura, lo que significa que es demasiado tarde para configurar el límite.

Si la aplicación debe reemplazar MaxRequestBodySize por solicitud, use IHttpMaxRequestBodySizeFeature:

app.Use((context, next) =>
{
    context.Features.GetRequiredFeature<IHttpMaxRequestBodySizeFeature>()
                                             .MaxRequestBodySize = 10 * 1024;

    var server = context.RequestServices
        .GetRequiredService<IServer>();
    var serverAddressesFeature = server.Features
                                 .GetRequiredFeature<IServerAddressesFeature>();

    var addresses = string.Join(", ", serverAddressesFeature.Addresses);

    var loggerFactory = context.RequestServices
        .GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    logger.LogInformation("Addresses: {addresses}", addresses);

    return next(context);
});

Si usa Visual Studio, asegúrese de que la aplicación no esté configurada para ejecutar IIS o IIS Express.

En Visual Studio, el perfil de inicio predeterminado es para IIS Express. Para ejecutar el proyecto como aplicación de consola, cambie manualmente el perfil seleccionado, tal y como se muestra en la siguiente captura de pantalla:

Seleccionar perfil de aplicación de consola

Configuración de Windows Server

  1. Determine los puertos que se van a abrir para la aplicación y use Windows Firewall o la New-NetFirewallRule cmdlet de PowerShell para abrir puertos de firewall para permitir que el tráfico llegue a HTTP.sys. En los comandos y la configuración de la aplicación siguientes, se usa el puerto 443.

  2. Al implementar en una máquina virtual de Azure, abra los puertos en el grupo de seguridad Network. En los comandos y la configuración de la aplicación siguientes, se usa el puerto 443.

  3. Si es necesario, obtenga e instale los certificados X.509.

    En Windows, cree certificados autofirmados mediante el cmdlet de PowerShell New-SelfSignedCertificate. Para obtener un ejemplo no compatible, vea UpdateIISExpressSSLForChrome.ps1.

    Instale certificados autofirmados o firmados por CA en el almacén Máquina local>Personal del servidor.

  4. Si la aplicación es una implementación dependiente del marco, instale el entorno de ejecución de ASP.NET Core y el entorno de ejecución de .NET correspondientes desde Descargas de .NET. El SDK de .NET no es necesario en el servidor. ASP.NET Core no tiene como destino .NET Framework. Para ver el contenido del instalador, consulte Elegir el entorno de ejecución correcto.

    Si la aplicación es una implementación autocontenida, incluye el entorno de ejecución en su implementación. No se requiere la instalación de ningún marco en el servidor.

  5. Configure los puertos y las direcciones URL en la aplicación.

    De forma predeterminada, ASP.NET Core enlaza a http://localhost:5000. Para configurar los puertos y los prefijos de dirección URL, las opciones incluyen lo siguiente:

    • UseUrls
    • urls argumento de la línea de comandos
    • La variable de entorno ASPNETCORE_URLS
    • UrlPrefixes

    En el código siguiente, se muestra cómo usar UrlPrefixescon la dirección IP local del servidor, 10.0.0.4, en el puerto 443:

    var builder = WebApplication.CreateBuilder(args);
    
    builder.WebHost.UseHttpSys(options =>
    {
        options.UrlPrefixes.Add("https://10.0.0.4:443");
    });
    
    builder.Services.AddRazorPages();
    
    var app = builder.Build();
    

    Una ventaja de UrlPrefixes es que se genera inmediatamente un mensaje de error para prefijos con formato incorrecto.

    La configuración de UrlPrefixes invalida la configuración de UseUrls/urls/ASPNETCORE_URLS. Por lo tanto, la ventaja de UseUrls, urls y la variable de entorno ASPNETCORE_URLS es que resulta más fácil de cambiar entre Kestrel y HTTP.sys.

    HTTP.sys reconoce dos tipos de caracteres comodín en prefijos de dirección URL.

    • * es una vinculación débil, también conocida como vinculación de reserva. Si el prefijo de dirección URL es http://*:5000y algo más está enlazado al puerto 5000, este enlace no se usará.
    • + es una vinculación fuerte. Si el prefijo de dirección URL es http://+:5000, este enlace se usará antes de otros enlaces de puerto 5000.

    Para obtener más información, consulte Cadenas de UrlPrefix.

    Warning

    Los enlaces de carácter comodín de nivel superior (http://*:80/ y http://+:80) no se deben usar. Los enlaces de comodín de más alto nivel crean vulnerabilidades de seguridad en las aplicaciones. Esto se aplica tanto a los caracteres comodín fuertes como a los débiles. Use nombres de host explícitos o direcciones IP en lugar de caracteres comodín. Los enlaces comodín de subdominio (por ejemplo, *.mysub.com) no suponen ningún riesgo de seguridad si se controla todo el dominio principal (a diferencia de *.com, que sí es vulnerable). Para obtener más información, consulte RFC 9110: Sección 7.2: Host y :authority.

    La mayoría de las configuraciones para aplicaciones y contenedores definen solo un puerto para escuchar, como el puerto 80, sin especificar otras restricciones como el host o la ruta de acceso. HTTP_PORTS y HTTPS_PORTS son claves de configuración que especifican los puertos de escucha para los Kestrel servidores y HTTP.sys. Puede especificar las claves como variables de entorno definidas con los DOTNET_ prefijos o ASPNETCORE_ , o establecerlas directamente a través de cualquier otra entrada de configuración, como el appsettings.json archivo . Cada configuración es una lista delimitada por punto y coma de valores de puerto, como se muestra en el ejemplo siguiente:

    ASPNETCORE_HTTP_PORTS=80;8080
    ASPNETCORE_HTTPS_PORTS=443;8081
    

    La configuración del ejemplo es abreviada para la especificación siguiente, que define el esquema (HTTP o HTTPS) y cualquier host o IP:

    ASPNETCORE_URLS=http://*:80/;http://*:8080/;https://*:443/;https://*:8081/
    

    Las HTTP_PORTS claves de configuración y HTTPS_PORTS son menor prioridad. Si otras direcciones URL o valores se establecen directamente en el código, pueden invalidar las claves de configuración. Configure certificados por separado mediante mecanismos específicos del servidor para HTTPS.

    Note

    No confunda la clave de configuración Kestrel ni la variable de entorno ASPNETCORE_HTTPS_PORT, que establecen los puertos para la configuración del punto de conexión de HTTPS_PORT/HTTP.sys, con la clave de configuración ni la variable de entorno HTTPS_PORTS, que establecen el puerto para el ASPNETCORE_HTTPS_PORTS.

    Estas claves de configuración son equivalentes a los enlaces de caracteres comodín de nivel superior. Son prácticos para escenarios de desarrollo y contenedor, pero evitan caracteres comodín cuando se ejecutan en una máquina que también puede hospedar otros servicios.

  6. Registre previamente los prefijos de URL en el servidor.

    La herramienta integrada para configurar HTTP.sys es netsh.exe. netsh.exe se usa para reservar prefijos de dirección URL y asignar certificados X.509. Esta herramienta requiere privilegios de administrador.

    Use la herramienta netsh.exe para registrar URL de la aplicación:

    netsh http add urlacl url=<URL> user=<USER>
    
    • <URL>: La dirección URL completa. No use ningún enlace de carácter comodín. Use un nombre de host válido o la dirección IP local. La dirección URL debe incluir una barra diagonal final.
    • <USER>: especifica el nombre del usuario o del grupo de usuarios.

    En el ejemplo siguiente, la dirección IP local del servidor es 10.0.0.4:

    netsh http add urlacl url=https://10.0.0.4:443/ user=Users
    

    Cuando se registra una dirección URL, la herramienta responde con URL reservation successfully added.

    Para eliminar una dirección URL registrada, use el comando delete urlacl:

    netsh http delete urlacl url=<URL>
    
  7. Registre certificados X.509 en el servidor.

    Use la herramienta netsh.exe para registrar certificados de la aplicación:

    netsh http add sslcert ipport=<IP>:<PORT> certhash=<THUMBPRINT> appid="{<GUID>}"
    
    • <IP>: especifica la dirección IP local para el enlace. No use ningún enlace de carácter comodín. Use una dirección IP válida.
    • <PORT>: especifica el puerto para el enlace.
    • <THUMBPRINT>: huella digital del certificado X.509.
    • <GUID>: GUID generado por el desarrollador para representar la aplicación con fines informativos.

    A modo de referencia, almacene el GUID en la aplicación como etiqueta de paquete:

    • En Visual Studio:
      • Para abrir las propiedades del proyecto de la aplicación, haga clic con el botón derecho en la aplicación en Explorador de soluciones y seleccione Properties.
      • Seleccione la pestaña Paquete.
      • Escribe el GUID que creaste en el campo Etiquetas.
    • Cuando no se usa Visual Studio:
      • Abra el archivo de proyecto de la aplicación.

      • Agregue una propiedad <PackageTags> a un elemento <PropertyGroup> nuevo o existente con el GUID que creó:

        <PropertyGroup>
          <PackageTags>00001111-aaaa-2222-bbbb-3333cccc4444</PackageTags>
        </PropertyGroup>
        

    En el ejemplo siguiente:

    • La dirección IP local del servidor es 10.0.0.4.
    • Un generador de GUID aleatorios en línea proporciona el valor appid.
    netsh http add sslcert
        ipport=10.0.0.4:443
        certhash=b66ee04419d4ee37464ab8785ff02449980eae10
        appid="{00001111-aaaa-2222-bbbb-3333cccc4444}"
    

    Cuando se registra un certificado, la herramienta responde con SSL Certificate successfully added.

    Para eliminar un registro de certificados, use el comando delete sslcert:

    netsh http delete sslcert ipport=<IP>:<PORT>
    

    Documentación de referencia de netsh.exe:

  8. Ejecutar la aplicación.

    Ejecute la aplicación con la identidad autorizada por la reserva de direcciones URL. Los privilegios de administrador son necesarios para configurar las reservas de direcciones URL y los enlaces de certificados, pero no son necesarios para ejecutar una aplicación cuya identidad tenga los permisos de espacio de nombres necesarios. El enlace a una dirección IP local o al puerto 443 no requiere un proceso de aplicación con privilegios elevados. Para obtener más información, consulte Reservas de espacios de nombres, registros y enrutamiento.

    La aplicación responde a la dirección IP pública del servidor. En este ejemplo, el servidor está disponible en Internet mediante su dirección IP pública, 104.214.79.47.

    En este ejemplo, se usa un certificado de desarrollo. La página se carga de forma segura tras omitir la advertencia de certificado no confiable del navegador.

    Ventana del explorador que muestra la página Índice de la aplicación cargada

Escenarios de servidor proxy y equilibrador de carga

En el caso de las aplicaciones hospedadas por HTTP.sys que interactúan con las solicitudes de Internet o de una red corporativa, puede que sea necesario configurar más elementos si esas aplicaciones se hospedan detrás de servidores proxy y equilibradores de carga. Para obtener más información, consulte Configure ASP.NET Core para trabajar con servidores proxy y equilibradores de carga.

Al procesar una solicitud con un Content-Length encabezado y un Transfer-Encoding encabezado cuya codificación final es chunked, HTTP.sys quita Content-Length de los encabezados de solicitud expuestos a la aplicación y cierra la conexión después de responder de forma predeterminada. Los servidores proxy no deben enviar tramas de solicitudes en conflicto. Este comportamiento ayuda a evitar el tráfico de solicitudes; no implica que cada solicitud de este tipo se rechace antes de llegar a la aplicación.

Inspeccione las propiedades TLS y de la solicitud

HTTP.sys expone características de solicitud para inspeccionar la información de TLS. La disponibilidad depende de la solicitud, la versión de Windows y la configuración de HTTP.sys.

Obtención del conjunto de cifrado TLS negociado

ITlsHandshakeFeature expone el conjunto de cifrado negociado a través de la propiedad NegotiatedCipherSuite para HTTP.sys. La característica no está disponible para una solicitud que no sea TLS. La propiedad puede ser null si Windows no admite la consulta o se produce un error en la consulta.

var handshake = context.Features.Get<ITlsHandshakeFeature>();
if (handshake?.NegotiatedCipherSuite is { } cipherSuite)
{
    logger.LogInformation("Negotiated TLS cipher suite: {CipherSuite}", cipherSuite);
}
else
{
    logger.LogInformation("The negotiated TLS cipher suite isn't available.");
}

Leer el ClientHello de TLS

Utilice TryGetTlsClientHello para recuperar los bytes sin procesar de TLS ClientHello a petición. La configuración del servicio HTTPS debe tener habilitado HTTP_SERVICE_CONFIG_SSL_FLAG_ENABLE_CACHE_CLIENT_HELLO. La configuración de ASP.NET Core para usar HTTP.sys no habilita esta marca nativa. Consulte HttpSetServiceConfiguration y HTTP_SERVICE_CONFIG_ID.

En primer lugar, llame al método con un intervalo vacío para obtener el tamaño de búfer necesario y, a continuación, asigne un búfer y vuelva a intentarlo:

var feature = context.Features.GetRequiredFeature<IHttpSysRequestPropertyFeature>();
_ = feature.TryGetTlsClientHello(Span<byte>.Empty, out var requiredSize);

var pooled = requiredSize <= 1024 ? ArrayPool<byte>.Shared.Rent(requiredSize) : null;
var buffer = pooled ?? new byte[requiredSize];
try
{
    if (!feature.TryGetTlsClientHello(buffer, out var bytesReturned))
    {
        throw new InvalidOperationException(
            $"The TLS ClientHello buffer must be resized to {bytesReturned} bytes.");
    }

    logger.LogInformation("Retrieved {ByteCount} TLS ClientHello bytes.", bytesReturned);
}
finally
{
    if (pooled is not null)
    {
        ArrayPool<byte>.Shared.Return(pooled);
    }
}

Consulta de otras propiedades de solicitud nativas

TryGetRequestProperty expone HttpQueryRequestProperty para propiedades arbitrarias de solicitud nativa.

  • propertyId identifica un valor de la enumeración nativa HTTP_REQUEST_PROPERTY .
  • qualifier contiene bytes opcionales específicos de la propiedad. Un intervalo vacío se pasa a Windows como un puntero nulo.
  • output recibe los bytes nativos. Quien realiza la llamada debe interpretarlos mediante la estructura de datos nativa correspondiente.
  • bytesReturned contiene los bytes escritos en caso de éxito. En un error de búfer insuficiente, la notificación del tamaño requerido depende de la propiedad nativa. Para las propiedades de tamaño fijo, asigne un tamaño de búfer para la estructura nativa correspondiente en lugar de suponer que una consulta de búfer vacío notifica el tamaño necesario.

En el ejemplo siguiente se consulta la propiedad TLS ClientHello a través de la API de uso general. Requiere la misma configuración nativa de almacenamiento en caché de ClientHello que TryGetTlsClientHello:

const int HttpRequestPropertyTlsClientHello = 11;
var feature = context.Features.GetRequiredFeature<IHttpSysRequestPropertyFeature>();
_ = feature.TryGetRequestProperty(
    HttpRequestPropertyTlsClientHello, qualifier: default, output: default,
    out var requiredSize);
var buffer = new byte[requiredSize];

if (!feature.TryGetRequestProperty(
    HttpRequestPropertyTlsClientHello, qualifier: default, output: buffer,
    out var bytesReturned))
{
    throw new InvalidOperationException(
        $"The request property buffer must be resized to {bytesReturned} bytes.");
}

logger.LogInformation("Retrieved {ByteCount} native request property bytes.", bytesReturned);

Obtención de tokens de enlace de canal

TryGetChannelBindingBytes proporciona acceso a bytes de enlace de canal TLS:

var tls = context.Features.Get<ITlsConnectionFeature>();
if (tls is not null &&
    tls.TryGetChannelBindingBytes(ChannelBindingKind.Endpoint, out var token))
{
    logger.LogInformation("TLS endpoint binding contains {ByteCount} bytes.", token.Length);
}
else
{
    logger.LogInformation("TLS endpoint channel binding isn't available.");
}

HTTP.sys admite ChannelBindingKind.Endpoint, correspondiente al tls-server-end-point enlace definido por RFC 5929. Otros tipos de enlace devuelven false. Un token no disponible también devuelve false. La exposición de CBT requiere que HTTP.sys aplique Medium o la Strictprotección de la autenticación.

La recuperación de los bytes de CBT no autentica por sí sola una solicitud ni aplica la protección Strict. Los bytes devueltos contienen la estructura Windows SEC_CHANNEL_BINDINGS y sus datos de enlace, no solo un hash de certificado.

Consiga información detallada de cronometraje con IHttpSysRequestTimingFeature

IHttpSysRequestTimingFeature proporciona información detallada de tiempo para las solicitudes:

  • Las marcas de tiempo se obtienen con QueryPerformanceCounter.
  • La frecuencia de las marcas de tiempo se puede obtener con QueryPerformanceFrequency.
  • El índice de control del tiempo se puede convertir en HttpSysRequestTimingType para saber qué representa el control del tiempo.
  • El valor puede ser 0 si no está disponible el tiempo para la solicitud actual.
  • Requiere Windows 10 versión 2004, Windows Server 2022 o posterior.
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();
    
    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var timestamps = feature.Timestamps;

    for (var i = 0; i < timestamps.Length; i++)
    {
        var timestamp = timestamps[i];
        var timingType = (HttpSysRequestTimingType)i;

        logger.LogInformation("Timestamp {timingType}: {timestamp}",
                                          timingType, timestamp);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

IHttpSysRequestTimingFeature.TryGetTimestamp recupera la marca de tiempo del tipo de tiempo proporcionado:

using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;
var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();

    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var timingType = HttpSysRequestTimingType.RequestRoutingEnd;

    if (feature.TryGetTimestamp(timingType, out var timestamp))
    {
        logger.LogInformation("Timestamp {timingType}: {timestamp}",
                                          timingType, timestamp);
    }
    else
    {
        logger.LogInformation("Timestamp {timingType}: not available for the "
                                           + "current request",    timingType);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

IHttpSysRequestTimingFeature.TryGetElapsedTime produce el tiempo transcurrido entre dos marcas de tiempo especificadas:

using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();

    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var startingTimingType = HttpSysRequestTimingType.RequestRoutingStart;
    var endingTimingType = HttpSysRequestTimingType.RequestRoutingEnd;

    if (feature.TryGetElapsedTime(startingTimingType, endingTimingType, out var elapsed))
    {
        logger.LogInformation(
            "Elapsed time {startingTimingType} to {endingTimingType}: {elapsed}",
            startingTimingType,
            endingTimingType,
            elapsed);
    }
    else
    {
        logger.LogInformation(
            "Elapsed time {startingTimingType} to {endingTimingType}:"
            + " not available for the current request.",
            startingTimingType,
            endingTimingType);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

Características avanzadas de HTTP/2 para admitir gRPC

Las características adicionales de HTTP/2 en HTTP.sys admiten gRPC, incluida la compatibilidad con los finalizadores de respuesta y el envío de marcos de restablecimiento.

Requisitos para ejecutar gRPC con HTTP.sys:

  • Windows 11 compilación 22000 o posterior, Windows Server 2022 compilación 20348 o posterior.
  • Conexión con TLS 1.2 o posterior.

Trailers

Los finalizadores HTTP son similares a los encabezados HTTP, salvo que se envían después de enviar el cuerpo de la respuesta. Para IIS y HTTP.sys, solo se admiten los finalizadores de respuesta HTTP/2.

if (httpContext.Response.SupportsTrailers())
{
    httpContext.Response.DeclareTrailer("trailername");	

    // Write body
    httpContext.Response.WriteAsync("Hello world");

    httpContext.Response.AppendTrailer("trailername", "TrailerValue");
}

En el código de ejemplo anterior:

  • SupportsTrailers garantiza que los trailers se admiten para la respuesta.
  • DeclareTrailer agrega el nombre del finalizador especificado al encabezado de respuesta Trailer. Declarar los finalizadores de una respuesta es opcional, pero se recomienda. Si se llama a DeclareTrailer, debe ser antes de que se envíen los encabezados de respuesta.
  • AppendTrailer anexa el finalizador.

Reset

Un restablecimiento permite que el servidor restablezca una solicitud HTTP/2 con un código de error especificado. Una solicitud de restablecimiento se considera abortada.

var resetFeature = httpContext.Features.Get<IHttpResetFeature>();
resetFeature.Reset(errorCode: 2);

Reset en el ejemplo de código anterior especifica el código de error INTERNAL_ERROR. Para obtener más información sobre los códigos de error HTTP/2, visite la sección de código de error de especificación de HTTP/2.

Tracing

Para obtener información sobre cómo obtener seguimientos de HTTP.sys, consulte Escenarios de administración de HTTP.sys.

Evicción automática del pool de memoria

Los grupos de memoria usados por Kestrel, IIS y HTTP.sys expulsan automáticamente los bloques de memoria cuando la aplicación está inactiva o bajo carga baja. La característica se ejecuta automáticamente y no es necesario habilitarla ni configurarla manualmente.

En las versiones de .NET anteriores a 10, la memoria asignada por el grupo permanece reservada, incluso cuando no está en uso. Esta característica de expulsión automática reduce el uso general de memoria y ayuda a las aplicaciones a mantener la capacidad de respuesta en distintas cargas de trabajo.

Utilizar métricas del grupo de memoria

El grupo de memoria predeterminado usado por las implementaciones del servidor de ASP.NET Core incluye métricas, que se pueden usar para supervisar y analizar patrones de uso de memoria. Las métricas están bajo el nombre "Microsoft.AspNetCore.MemoryPool".

Para obtener información sobre las métricas y cómo usarlas, consulte ASP.NET Core metrics.

Administración de grupos de memoria

Además de usar grupos de memoria de forma eficaz al expulsar bloques de memoria innecesarios, ASP.NET Core proporciona una IMemoryPoolFactory integrada y una implementación. Hace que la implementación esté disponible para la aplicación a través de la inserción de dependencias.

En el ejemplo de código siguiente se muestra un servicio en segundo plano sencillo que usa la implementación integrada del generador de grupos de memoria para crear grupos de memoria. Estos grupos se benefician de la característica de expulsión automática:

public class MyBackgroundService : BackgroundService
{
    private readonly MemoryPool<byte> _memoryPool;

    public MyBackgroundService(IMemoryPoolFactory<byte> factory)
    {
        _memoryPool = factory.Create();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await Task.Delay(20, stoppingToken);
                // do work that needs memory
                // consider checking _memoryPool.MaxBufferSize
                var rented = _memoryPool.Rent(100);
                rented.Dispose();
            }
            catch (OperationCanceledException)
            {
                return;
            }
        }
    }
}

Para usar una fábrica de grupos de memoria personalizada, cree una clase que implemente IMemoryPoolFactory y regístrela con la inserción de dependencias, como hace el ejemplo siguiente. Los grupos de memoria creados de esta manera no se benefician de la característica de expulsión automática a menos que implemente una lógica de expulsión similar en la factoría personalizada:

services.AddSingleton<IMemoryPoolFactory<byte>,
CustomMemoryPoolFactory>();

public class CustomMemoryPoolFactory : IMemoryPoolFactory<byte>
{
    public MemoryPool<byte> Create()
    {
        // Return a custom MemoryPool implementation
        // or the default, as is shown here.
        return MemoryPool<byte>.Shared;
    }
}

Cuando utilice un grupo de memoria, ten en cuenta el MaxBufferSize del grupo.

Note

Los vínculos de la documentación al origen de referencia de .NET cargan normalmente la rama predeterminada del repositorio, que representa el desarrollo actual para la próxima versión de .NET. Para seleccionar una etiqueta para una versión específica, use la lista desplegable Cambiar ramas o etiquetas .