Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Note
Esta não é a versão mais recente deste artigo. Para a versão atual, consulte a versão .NET 11 deste artigo.
Por Tom Dykstra e Chris Ross
HTTP.sys é um servidor Web para ASP.NET Core que é executado apenas em Windows. O HTTP.sys é uma alternativa ao servidor Kestrel e oferece alguns recursos que o Kestrel não fornece. Este artigo explica quando usar HTTP.sys, como configurá-lo e como inspecionar informações de solicitação e TLS.
Important
HTTP.sys não é compatível com o módulo ASP.NET Core e não pode ser usado com o IIS ou o IIS Express.
O HTTP.sys dá suporte aos seguintes recursos:
- Autenticação Windows
- Compartilhamento de porta
- HTTPS com SNI
- HTTP/2 por TLS (Windows 10 ou posterior)
- HTTP/3 por TLS (Windows 11 ou posterior)
- Transmissão direta de arquivo
- Cache de resposta
- WebSockets (Windows 8 ou posterior)
- Descritores de segurança personalizáveis
- Remoção automática do pool de memória
O sistema operacional deve ser suportado pela versão de destino do aplicativo do .NET. Para versões de Windows com suporte, consulte Instalar .NET no Windows. A disponibilidade de HTTP.sys em versões de Windows mais antigas não implica suporte para essas versões pelas versões ASP.NET Core atuais. Recursos individuais podem ter requisitos de Windows adicionais, conforme descrito nas seções a seguir.
Exibir ou baixar código de exemplo (como baixar)
Quando usar o HTTP.sys
O HTTP.sys é útil nas implantações em que:
É necessário expor o servidor diretamente à Internet sem usar o IIS.
Uma implantação interna requer um recurso não disponível no Kestrel. Para obter mais informações, confira Kestrel vs. HTTP.sys
O HTTP.sys é uma tecnologia madura que protege contra vários tipos de ataques e proporciona as propriedades de robustez, segurança e escalabilidade de um servidor Web completo. O próprio IIS opera como um ouvinte de HTTP sobre o HTTP.sys.
Suporte do HTTP/2
HTTP/2 está habilitado para aplicativos ASP.NET Core quando os seguintes requisitos base são atendidos:
- Windows Server 2016/Windows 10 ou posterior
- Conexão ALPN (Negociação de protocolo de camada de aplicativo)
- Conexão TLS 1.2 ou posterior
Se uma conexão HTTP/2 for estabelecida, HttpRequest.Protocol relatará HTTP/2.
O HTTP/2 está habilitado por padrão. Se uma conexão HTTP/2 não tiver sido estabelecida, a conexão retornará para HTTP/1.1. Em Windows versões que dão suporte a ele, a opção disablehttp2 em uma netsh http associação de certificado SSL desabilita HTTP/2 para essa associação. Para obter as opções disponíveis, consulte netsh http.
Suporte a HTTP/3
HTTP/3 está habilitado para aplicativos ASP.NET Core quando os seguintes requisitos base são atendidos:
- Windows Server 2022/Windows 11 ou posterior
- Uma associação de URL
httpsé usada. - A chave do Registro EnableHttp3 está definida.
As versões anteriores Windows 11 Build podem exigir o uso de uma compilação Windows Insider.
O HTTP/3 for descoberto como uma atualização do HTTP/1.1 ou HTTP/2 por meio do cabeçalho alt-svc. Isso significa que a primeira solicitação normalmente usará HTTP/1.1 ou HTTP/2 antes de alternar para HTTP/3. Http.Sys não adiciona automaticamente o cabeçalho alt-svc; ele deve ser adicionado pelo aplicativo. O código a seguir é um exemplo de middleware que adiciona o cabeçalho de resposta alt-svc.
app.Use((context, next) =>
{
context.Response.Headers.AltSvc = "h3=\":443\"";
return next(context);
});
Coloque o código anterior no início do pipeline de solicitação.
Http.Sys também dá suporte ao envio de uma mensagem de protocolo HTTP/2 AltSvc em vez de um cabeçalho de resposta para notificar o cliente de que HTTP/3 está disponível. Confira a chave do Registro EnableAltSvc.
Note
Isso requer associações netsh sslcert que usam nomes de host em vez de endereços IP.
ipport Substitua hostnameport nos netsh http add sslcert comandos abaixo e substitua o endereço IP pelo nome do host, por exemplo, www.example.com. Há também um problema conhecido em que o uso hostnameport falha, a menos que o certstorename parâmetro seja especificado. Por padrão, use certstorename=MY.
Autenticação de modo kernel com Kerberos
O HTTP.sys delega a autenticação de modo kernel ao protocolo de autenticação Kerberos. Não há suporte para autenticação de modo de usuário com o Kerberos e o HTTP.sys. A conta do computador deve ser usada para descriptografar o token/tíquete Kerberos obtido de Active Directory e encaminhado pelo cliente para o servidor para autenticar o usuário. Registre o SPN (nome da entidade de serviço) do host, não do usuário do aplicativo.
Ativar a robustez do token de associação de canal (CBT)
Os tokens de associação de canal (CBT) vinculam a autenticação do Windows ao canal TLS subjacente, o que ajuda a atenuar a retransmissão NTLM e ataques de intermediário.
Configurar o reforço de segurança de CBT com HttpAuthenticationHardeningLevel. Os valores disponíveis HttpAuthenticationHardeningLevel são:
| Valor | Behavior |
|---|---|
Legacy |
Não impõe a validação de associação de canal nem expõe bytes CBT ao aplicativo. |
Medium (predefinição) |
Valida os CBTs quando os clientes os fornecem, mas permite sua ausência. Expõe bytes CBT ao aplicativo. |
Strict |
Requer CBTs em solicitações autenticadas e rejeita solicitações sem elas. Expõe bytes CBT ao aplicativo. |
O exemplo a seguir opta por usar a proteção Strict:
builder.WebHost.UseHttpSys(options =>
{
options.HttpAuthenticationHardeningLevel =
HttpAuthenticationHardeningLevel.Strict;
});
Se HTTP.sys não puder aplicar hardening de Strict, a inicialização do servidor falhará com um HttpSysException. Com Legacy ou Medium, uma falha na aplicação da configuração é registrada e a inicialização continua. O valor configurado por si só não garante que o sistema operacional tenha aplicado a configuração.
Warning
StrictO reforço de segurança pode fazer com que autenticação do Windows falhar para clientes ou proxies que não fornecem um CBT válido. Teste a compatibilidade do cliente e a terminação TLS em seu ambiente antes de habilitá-la em produção.
Ao anexar a uma fila de solicitações existente, configure a proteção no listener que possui o grupo de URLs. O aplicativo que se anexa não aplica a configuração do grupo de URL.
Para obter acesso a bytes CBT, consulte Obter tokens de associação de canal.
Ative o reforço de segurança de CBT para pontos de extremidade HTTPS que usam autenticação do Windows definindo a opção Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening AppContext como true. Essa opção seleciona o endurecimento médio, que valida os CBTs fornecidos, mas permite sua ausência.
Habilite o interruptor no arquivo runtimeconfig.template.json do projeto:
{
"configProperties": {
"Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening": true
}
}
Como alternativa, defina a opção programaticamente antes de compilar o host no Program arquivo:
AppContext.SetSwitch("Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening", true);
Warning
A proteção do CBT está desativada por padrão. Habilitá-lo pode fazer com que a autenticação do Windows falhe para os clientes ou proxies que não dão suporte à associação de canal. Teste minuciosamente em seu ambiente antes de habilitar em produção.
Suporte para buffers de resposta no modo núcleo
Em alguns cenários, altos volumes de gravações pequenas com alta latência podem impactar significativamente o desempenho de HTTP.sys. Esse impacto ocorre devido à falta de um buffer Pipe na implementação HTTP.sys. Para melhorar o desempenho nesses cenários, o suporte para buffer de resposta está incluído no HTTP.sys. Habilitar o buffer definindo EnableKernelResponseBuffering como true.
O buffer de resposta deve ser habilitado por um aplicativo que realiza entrada/saída síncrona ou entrada/saída assíncrona com não mais de uma gravação pendente por vez. Nesses cenários, o buffer de resposta pode melhorar significativamente a taxa de transferência em relação a conexões de alta latência.
Aplicativos que usam E/S assíncrona e que podem ter mais de uma gravação pendente ao mesmo tempo não devem usar esse sinalizador. Habilitar esse sinalizador pode resultar em maior uso de CPU e memória por HTTP.Sys.
Como usar o HTTP.sys
Configurar o aplicativo ASP.NET Core para usar HTTP.sys
Chame o método de extensão UseHttpSys ao configurar o host, especificando qualquer HttpSysOptions necessário. O exemplo a seguir define as opções para seus valores padrão:
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();
A configuração adicional do HTTP.sys é tratada por meio das configurações do registro.
Para obter mais informações sobre as opções HTTP.sys, confira HttpSysOptions.
Personalizar descritores de segurança
Uma fila de solicitações no HTTP.sys é uma estrutura no nível do kernel que armazena temporariamente solicitações HTTP de entrada até que seu aplicativo esteja pronto para processá-las. Gerenciar o acesso à fila de solicitação usando RequestQueueSecurityDescriptor. Defina-a como uma GenericSecurityDescriptor instância ao configurar seu servidor HTTP.sys.
Ao personalizar o descritor de segurança, você pode permitir ou negar acesso de usuários ou grupos específicos à fila de solicitações. Isso é útil em cenários em que você deseja restringir ou delegar o tratamento de solicitações HTTP.sys no nível do sistema operacional.
Por exemplo, o código a seguir permite todos os usuários autenticados, mas nega aos convidados:
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;
});
A RequestQueueSecurityDescriptor propriedade se aplica somente ao criar uma nova fila de solicitação. A propriedade não afeta as filas de solicitação existentes. Quando RequestQueueMode é Attach, uma fila existente é aberta, opções de nível de fila, como RequestQueueSecurityDescriptor e RequestQueueLimit, não se aplicam. No Attach modo, as configurações de grupo de URL, como tempos limite e proteção de autenticação, devem ser configuradas pelo ouvinte que possui o grupo de URLs, e UrlPrefixes é usado apenas para calcular PathBase.
CreateOrAttach ainda configura seu próprio grupo de URLs e registra seu UrlPrefixes, mesmo quando a fila já existe; as configurações para prefixos já registrados por outro ouvinte permanecem controladas por esse ouvinte.
MaxRequestBodySize
O tamanho máximo permitido em bytes para qualquer corpo de solicitação. Quando é definido como null, o tamanho máximo do corpo da solicitação é ilimitado. Esse limite não afeta as conexões atualizadas que são sempre ilimitadas.
O método recomendado para substituir o limite em um aplicativo MVC ASP.NET Core para um único IActionResult é usar o atributo RequestSizeLimitAttribute em um método de ação:
[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()
Uma exceção é gerada quando o aplicativo tenta configurar o limite de uma solicitação, depois que o aplicativo inicia a leitura da solicitação. É possível usar uma propriedade IsReadOnly para indicar se a propriedade MaxRequestBodySize está no estado somente leitura, o que significa que é tarde demais para configurar o limite.
Se o aplicativo precisar substituir MaxRequestBodySize mediante solicitação, use o 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);
});
Se estiver usando Visual Studio, verifique se o aplicativo não está configurado para executar o IIS ou o IIS Express.
Em Visual Studio, o perfil de inicialização padrão é para o IIS Express. Para executar o projeto como um aplicativo de console, altere manualmente o perfil selecionado, conforme mostrado na captura de tela a seguir:
Configurar Windows Server
Determine as portas a serem abertas para o aplicativo e use Windows Firewall ou o cmdlet New-NetFirewallRule PowerShell para abrir portas de firewall para permitir que o tráfego alcance HTTP.sys. Nos seguintes comandos e configuração de aplicativo, a porta 443 é usada.
Ao implantar em uma VM Azure, abra as portas no Network Security Group. Nos seguintes comandos e configuração de aplicativo, a porta 443 é usada.
Obtenha e instale os certificados X.509, se precisar.
Em Windows, crie certificados autoassinados usando o cmdlet New-SelfSignedCertificate PowerShell. Para ver um exemplo sem suporte, confira UpdateIISExpressSSLForChrome.ps1.
Instale certificados autoassinados ou assinados pela Autoridade Certificadora no repositório Computador Local>Pessoal do servidor.
Se o aplicativo for uma implantação dependente da estrutura, instale os runtimes correspondentes do ASP.NET Core e do .NET em .NET Downloads. O SDK do .NET não é necessário no servidor. ASP.NET Core não tem como destino .NET Framework. Para obter o conteúdo do instalador, consulte Escolher o runtime correto.
Se o aplicativo for uma implantação autocontida, ele incluirá o runtime em sua implantação. Nenhuma instalação do framework é necessária no servidor.
Configure URLs e portas no aplicativo.
Por padrão, ASP.NET Core se associa a
http://localhost:5000. Para configurar portas e prefixos de URL, as opções incluem:- UseUrls
- O argumento de linha de comando
urls - A variável de ambiente
ASPNETCORE_URLS - UrlPrefixes
O exemplo de código a seguir mostra como usar UrlPrefixes com o endereço IP local do servidor
10.0.0.4na porta 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();Uma vantagem de usar
UrlPrefixesé que uma mensagem de erro é gerada imediatamente no caso de prefixos formatados de forma incorreta.As configurações de
UrlPrefixessubstituem as configuraçõesUseUrls/urls/ASPNETCORE_URLS. Portanto, uma vantagem de usarUseUrls,urlse a variável de ambienteASPNETCORE_URLSé que fica mais fácil alternar entre o Kestrel e o HTTP.sys.O HTTP.sys reconhece dois tipos de curingas em prefixos de URL:
-
*é uma associação fraca, também conhecida como associação de fallback. Se o prefixo de URL forhttp://*:5000e algo mais estiver associado à porta 5000, essa associação não será usada. -
+é uma binding forte. Se o prefixo de URL forhttp://+:5000, essa associação será usada antes de outras associações da porta 5000.
Para obter mais informações, consulte Cadeias de caracteres UrlPrefix.
Warning
Associações de curinga de nível superior (
http://*:80/ehttp://+:80) não devem ser usadas. Associações de curinga de nível superior criam vulnerabilidades de segurança no aplicativo. Isso se aplica a curingas fortes e fracos. Use nomes de host explícitos ou endereços IP em vez de curingas. Associações de curinga de subdomínio (por exemplo,*.mysub.com) não serão um risco à segurança se você controlar todo o domínio pai (ao contrário de*.com, o qual é vulnerável). Para obter mais informações, confira RFC 9110: Seção 7.2: Host e :authority.A maioria das configurações para aplicativos e contêineres define apenas uma porta para escuta, como a porta 80, sem especificar outras restrições, como o host ou o caminho.
HTTP_PORTSeHTTPS_PORTSsão chaves de configuração que especificam as portas de escuta para os Kestrel servidores e HTTP.sys. Você pode especificar as chaves como variáveis de ambiente definidas com os prefixosDOTNET_ouASPNETCORE_, ou defini-las diretamente por meio de qualquer outra fonte de configuração, como o arquivoappsettings.json. Cada configuração é uma lista delimitada por ponto-e-vírgula de valores de porta, conforme mostrado no exemplo a seguir:ASPNETCORE_HTTP_PORTS=80;8080 ASPNETCORE_HTTPS_PORTS=443;8081A configuração no exemplo é abreviada para a seguinte especificação, que define o esquema (HTTP ou HTTPS) e qualquer host ou IP:
ASPNETCORE_URLS=http://*:80/;http://*:8080/;https://*:443/;https://*:8081/As chaves de configuração
HTTP_PORTSeHTTPS_PORTStêm menor prioridade. Se outras URLs ou valores forem definidos diretamente no código, eles poderão substituir as chaves de configuração. Configure certificados separadamente usando a mecânica específica do servidor para HTTPS.Note
Não confunda a chave de configuração
HTTPS_PORTSe a variável de ambienteASPNETCORE_HTTPS_PORTS, que definem as portas para a configuração de ponto de extremidade Kestrel/HTTP.sys, com a chave de configuraçãoHTTPS_PORTe a variável de ambienteASPNETCORE_HTTPS_PORT, que definem a porta para o middleware de redirecionamento HTTPS.Essas chaves de configuração são equivalentes a associações curinga de nível superior. Elas são convenientes para cenários de desenvolvimento e contêiner, mas evitam caracteres curinga quando executadas em um computador que também pode hospedar outros serviços.
Pré-registre os prefixos de URL no servidor.
O netsh.exe é a ferramenta interna destinada a configurar o HTTP.sys. netsh.exe é usado para reservar prefixos de URL e atribuir certificados X.509. A ferramenta exige privilégios de administrador.
Use a ferramenta netsh.exe para registrar as URLs do aplicativo:
netsh http add urlacl url=<URL> user=<USER>-
<URL>: a URL (Uniform Resource Locator) totalmente qualificada. Não use uma associação de curinga. Use um nome de host válido ou o endereço IP local. A URL deve incluir uma barra final. -
<USER>: especifica o nome de usuário ou grupo de usuários.
No exemplo a seguir, o endereço IP local do servidor é
10.0.0.4:netsh http add urlacl url=https://10.0.0.4:443/ user=UsersQuando uma URL é registrada, a ferramenta responde com
URL reservation successfully added.Para excluir uma URL registrada, use o comando
delete urlacl:netsh http delete urlacl url=<URL>-
Registre certificados X.509 no servidor.
Use a ferramenta netsh.exe para registrar certificados do aplicativo:
netsh http add sslcert ipport=<IP>:<PORT> certhash=<THUMBPRINT> appid="{<GUID>}"-
<IP>: especifica o endereço IP local para o vínculo. Não use uma associação de curinga. Use um endereço IP válido. -
<PORT>: especifica a porta para a vinculação. -
<THUMBPRINT>: a impressão digital do certificado X.509. -
<GUID>: um GUID gerado pelo desenvolvedor para representar o aplicativo para fins informativos.
Para fins de referência, armazene o GUID no aplicativo como uma marca de pacote:
- Em Visual Studio:
- Abra as propriedades do projeto do aplicativo clicando com o botão direito do mouse no aplicativo em Gerenciador de Soluções e selecionando Properties.
- Selecione a guia Pacote.
- Insira o GUID que você criou no campo Marcas.
- Ao não usar Visual Studio:
Abra o arquivo de projeto do aplicativo.
Adicione uma propriedade
<PackageTags>a um<PropertyGroup>novo ou existente com o GUID que você criou:<PropertyGroup> <PackageTags>00001111-aaaa-2222-bbbb-3333cccc4444</PackageTags> </PropertyGroup>
No exemplo a seguir:
- O endereço IP local do servidor é
10.0.0.4. - Um gerador GUID aleatório online fornece o valor
appid.
netsh http add sslcert ipport=10.0.0.4:443 certhash=b66ee04419d4ee37464ab8785ff02449980eae10 appid="{00001111-aaaa-2222-bbbb-3333cccc4444}"Quando um certificado é registrado, a ferramenta responde com
SSL Certificate successfully added.Para excluir um registro de certificado, use o comando
delete sslcert:netsh http delete sslcert ipport=<IP>:<PORT>Documentação de referência do netsh.exe:
-
Execute o aplicativo.
Execute o aplicativo na identidade autorizada pela reserva de URL. Privilégios de administrador são necessários para configurar reservas de URL e associações de certificado, mas não são necessários para executar um aplicativo cuja identidade tem as permissões de namespace necessárias. A associação a um endereço IP local ou à porta 443 por si só não requer um processo de aplicativo com privilégios elevados. Para obter mais informações, consulte reservas, registros e roteamento do Namespace.
O aplicativo responde no endereço IP público do servidor. Neste exemplo, o servidor é acessado a partir da Internet em seu endereço IP público de
104.214.79.47.Um certificado de desenvolvimento é usado neste exemplo. A página é carregada com segurança após ignorar o aviso de certificado não confiável do navegador.
Servidor proxy e cenários de balanceador de carga
Para aplicativos hospedados pelo HTTP.sys que interagem com solicitações da Internet ou de uma rede corporativa, podem ser necessárias configurações adicionais ao hospedar atrás de balanceadores de carga e de servidores proxy. Para obter mais informações, consulte Configure ASP.NET Core para trabalhar com servidores proxy e balanceadores de carga.
Ao processar uma solicitação com um Content-Length cabeçalho e um Transfer-Encoding cabeçalho cuja codificação final é chunked, HTTP.sys remove dos cabeçalhos Content-Length de solicitação exibidos para o aplicativo e fecha a conexão depois de responder por padrão. Proxies não devem enviar delimitação da solicitação conflitante. Esse comportamento ajuda a evitar o contrabando de solicitações; isso não implica que cada solicitação desse tipo seja rejeitada antes de chegar ao aplicativo.
Inspecionar propriedades de solicitação e TLS
HTTP.sys expõe recursos de solicitação para inspecionar informações do TLS. A disponibilidade depende da solicitação, da versão do Windows e da configuração de HTTP.sys.
Obter o conjunto de cifras TLS negociado
ITlsHandshakeFeature expõe o conjunto de criptografias negociado por meio de sua propriedade NegotiatedCipherSuite para HTTP.sys. O recurso não está disponível para uma solicitação não TLS. A propriedade pode ser null se Windows não der suporte à consulta ou a consulta falhar.
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.");
}
Ler o ClientHello do TLS
Use TryGetTlsClientHello para recuperar os bytes TLS ClientHello brutos sob demanda. A configuração do serviço HTTPS deve habilitar HTTP_SERVICE_CONFIG_SSL_FLAG_ENABLE_CACHE_CLIENT_HELLO. Configurar o ASP.NET Core para usar o HTTP.sys não habilita esse sinalizador nativo. Consulte HttpSetServiceConfiguration e HTTP_SERVICE_CONFIG_ID.
Primeiro chame o método com um intervalo vazio para obter o tamanho do buffer necessário e, em seguida, aloque um buffer e tente novamente:
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);
}
}
Consultar outras propriedades de solicitação nativa
TryGetRequestProperty expõe HttpQueryRequestProperty para propriedades arbitrárias de solicitação nativa.
-
propertyIdidentifica um valor da enumeração nativaHTTP_REQUEST_PROPERTY. -
qualifiercontém bytes opcionais específicos da propriedade. Um span vazio é passado para Windows como um ponteiro nulo. -
outputrecebe os bytes nativos. O chamador deve interpretá-los usando a estrutura de dados nativa correspondente. -
bytesReturnedcontém os bytes escritos com êxito. Em uma falha de buffer insuficiente, o relatório de tamanho necessário depende da propriedade nativa. Para propriedades de tamanho fixo, aloque um buffer dimensionado para a estrutura nativa correspondente em vez de assumir que uma consulta de buffer vazio relata o tamanho necessário.
O exemplo a seguir consulta a propriedade TLS ClientHello por meio da API de uso geral. Ele requer a mesma configuração de cache do ClientHello nativo, assim como 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);
Obter tokens de associação de canal
TryGetChannelBindingBytes fornece acesso aos bytes de associação de canal do 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 dá suporte a ChannelBindingKind.Endpoint, correspondente à associação tls-server-end-point definida pelo RFC 5929. Outros tipos de associação retornam false. Um token indisponível também retorna false. A exposição ao CBT exige que uma proteção de autenticação Medium ou Strict seja aplicada pelo HTTP.sys.
A recuperação de bytes CBT não autentica por si só uma solicitação nem impõe Strict reforço de segurança. Os bytes retornados contêm a estrutura Windows SEC_CHANNEL_BINDINGS e seus dados de associação, não apenas um hash de certificado.
Obter informações detalhadas de tempo com IHttpSysRequestTimingFeature
IHttpSysRequestTimingFeature fornece informações detalhadas de tempo para solicitações:
- Os carimbos de data/hora são obtidos por meio deQueryPerformanceCounter.
- A frequência de timestamp pode ser obtida através de QueryPerformanceFrequency.
- O índice do tempo pode ser convertido em HttpSysRequestTimingType para saber o que o tempo representa.
- O valor poderá ser 0 se o tempo não estiver disponível para a solicitação atual.
- Requer Windows 10 versão 2004, Windows Server 2022 ou 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 o carimbo de data/hora para o tipo de temporização fornecido:
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 gera o tempo decorrido entre dois tempos especificados:
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();
Recursos HTTP/2 avançados para dar suporte a gRPC
Os recursos HTTP/2 adicionais em HTTP.sys dão suporte a gRPC, incluindo suporte para trailers de resposta e envio de quadros de redefinição.
Requisitos para executar o gRPC com HTTP.sys:
- Windows 11 Build 22000 ou posterior, Windows Server 2022 Build 20348 ou posterior.
- Conexão TLS 1.2 ou posterior.
Trailers
Os trailers HTTP são semelhantes aos cabeçalhos HTTP, exceto por serem enviados após o corpo da resposta ser enviado. Para IIS e HTTP.sys, há suporte apenas para trailers de resposta HTTP/2.
if (httpContext.Response.SupportsTrailers())
{
httpContext.Response.DeclareTrailer("trailername");
// Write body
httpContext.Response.WriteAsync("Hello world");
httpContext.Response.AppendTrailer("trailername", "TrailerValue");
}
No código de exemplo anterior:
-
SupportsTrailersgarante que os trailers sejam compatíveis com a resposta. -
DeclareTraileradiciona o nome do trailer fornecido ao cabeçalho de respostaTrailer. Declarar os trailers de uma resposta é opcional, mas recomendado. SeDeclareTrailerfor chamado, deverá ser antes que os cabeçalhos de resposta sejam enviados. - O
AppendTraileracrescenta o trailer.
Reset
A opção Redefinir permite que o servidor redefina uma solicitação HTTP/2 com um código de erro especificado. Uma solicitação de redefinição é considerada anulada.
var resetFeature = httpContext.Features.Get<IHttpResetFeature>();
resetFeature.Reset(errorCode: 2);
Reset no exemplo de código anterior especifica o código de erro INTERNAL_ERROR. Para obter mais informações sobre códigos de erro HTTP/2, visite a seção de código de erro de especificação HTTP/2.
Tracing
Para obter informações sobre como obter rastreamentos de HTTP.sys, consulte Cenários de capacidade de gerenciamento de HTTP.sys.
Descarte automático do pool de memória
Os pools de memória usados por Kestrel, IIS e HTTP.sys removem automaticamente blocos de memória quando o aplicativo está ocioso ou sob pouca carga. O recurso é executado automaticamente e não precisa ser habilitado ou configurado manualmente.
Em versões de .NET anteriores a 10, a memória alocada pelo pool permanece reservada, mesmo quando não estiver em uso. Esse recurso de remoção automática reduz o uso geral de memória e ajuda os aplicativos a permanecerem responsivos em cargas de trabalho variadas.
Usar métricas do pool de memória
O pool de memória padrão usado pelas implementações do servidor ASP.NET Core inclui métricas, que podem ser usadas para monitorar e analisar padrões de uso de memória. As métricas estão sob o nome "Microsoft.AspNetCore.MemoryPool".
Para obter informações sobre métricas e como usá-las, consulte ASP.NET Core métricas.
Gerenciar reservatórios de memória
Além de usar pools de memória de forma eficiente através da evicção de blocos de memória desnecessários, o ASP.NET Core fornece uma IMemoryPoolFactory interna e uma implementação. Isso disponibiliza a implementação para o aplicativo por meio da injeção de dependência.
O exemplo de código a seguir mostra um serviço em segundo plano simples que usa a implementação integrada de fábrica de pools de memória para criar pools de memória. Esses pools se beneficiam do recurso de remoção 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 uma fábrica de pool de memória personalizada, crie uma classe que implemente IMemoryPoolFactory e registre-a com injeção de dependência, como mostra o exemplo a seguir. Os pools de memória criados dessa forma não se beneficiam do recurso de remoção automática, a menos que você implemente uma lógica de remoção semelhante em sua fábrica 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;
}
}
Ao usar um pool de memória, fique atento ao MaxBufferSize do pool.
Conteúdo relacionado
- Habilitar a Autenticação Windows com HTTP.sys
- API do servidor HTTP
- implementação do HTTP.sys no repositório ASP.NET Core (código-fonte)
- O host
- Solucionar problemas e depurar projetos do ASP.NET Core
Note
Os links da documentação para o código-fonte de referência do .NET geralmente carregam a ramificação padrão do repositório, que representa o estágio atual de desenvolvimento da próxima versão do .NET. Para selecionar uma tag para uma release específica, use a lista suspensa Alternar branches ou tags.