Végpontok konfigurálása a ASP.NET Core Kestrel webkiszolgálóhoz

Cikk
02/05/2025

Jegyzet

Ez nem a cikk legújabb verziója. Az aktuális kiadás megtekintéséhez lásd ennek a cikknek a .NET 9-es verzióját.

Figyelmeztetés

A ASP.NET Core ezen verziója már nem támogatott. További információ: .NET és .NET Core támogatási szabályzat. Az aktuális kiadásról lásd a jelen cikk .NET 9-es változatát .

Fontos

Ezek az információk egy olyan előzetes termékre vonatkoznak, amelyet a kereskedelmi forgalomba kerülés előtt jelentősen módosíthatnak. A Microsoft nem vállal kifejezett vagy hallgatólagos szavatosságot az itt megadott információkra vonatkozóan.

A jelen cikk .NET 9 verziójára vonatkozóan lásd az aktuális kiadás.

Kestrel végpontok biztosítják az infrastruktúrát a bejövő kérések figyeléséhez és a megfelelő köztes szoftverhez való átirányításhoz. Egy cím és egy protokoll kombinációja definiál egy végpontot.

A cím megadja azt a hálózati adaptert, amelyen a kiszolgáló figyeli a bejövő kéréseket, például egy TCP-portot.
A protokoll az ügyfél és a kiszolgáló közötti kommunikációt határozza meg, például HTTP/1.1, HTTP/2 vagy HTTP/3.
A végpontok az https URL-sémával vagy UseHttps metódussal védhetők.

A végpontok konfigurálhatók URL-címek, JSON appsettings.jsonés kód használatával. Ez a cikk azt ismerteti, hogyan konfigurálhat végpontokat az egyes beállítások használatával:

Végpontok konfigurálása
HTTPS- konfigurálása
HTTP-protokollok konfigurálása

Alapértelmezett végpont

Az új ASP.NET Core-projektek úgy vannak konfigurálva, hogy 5000–5300 közötti véletlenszerű HTTP-porthoz és 7000–7300 közötti véletlenszerű HTTPS-porthoz kössenek. A kiválasztott portok a létrehozott Properties/launchSettings.json fájlban vannak tárolva, és a fejlesztő módosíthatja őket. A launchSetting.json fájl csak a helyi fejlesztésben használatos.

Ha nincs végpontkonfiguráció, akkor a Kestrel kapcsolódik a http://localhost:5000-hez.

Végpontok konfigurálása

Kestrel végpontok figyelik a bejövő kapcsolatokat. Amikor létrehoz egy végpontot, konfigurálnia kell azt azzal a címmel, amelyet figyelni fog. Ez általában egy TCP-cím és portszám.

A végpontok konfigurálásának számos lehetősége van:

Végpontok konfigurálása URL-címekkel
Csak a portok megadása
Végpontok konfigurálása a appsettings.json
Végpontok konfigurálása a kódban

Végpontok konfigurálása URL-címekkel

A következő szakaszok ismertetik, hogyan lehet konfigurálni a végpontokat a következő módon:

ASPNETCORE_URLS környezeti változó.
--urls parancssori argumentum.
urls gazda konfigurációs kulcs.
UseUrls bővítménymetódus.
WebApplication.Urls tulajdonság.

URL-formátumok

Az URL-címek azt az IP-címet vagy gazdagépcímet jelzik, amelyen a kiszolgálónak figyelnie kell a portokat és protokollokat. A port elhagyható, ha ez a protokoll alapértelmezett értéke (általában 80 és 443). Az URL-címek az alábbi formátumok bármelyikében lehetnek.

IPv4-cím portszámmal
```
http://65.55.39.10:80/
```
0.0.0.0 egy speciális eset, amely az összes IPv4-címhez kötődik.
IPv6-cím portszámmal
```
http://[0:0:0:0:0:ffff:4137:270a]:80/
```
[::] az IPv4 0.0.0.0IPv6-megfelelője.
Helyettesítő karakter gazdagép portszámmal
```
http://contoso.com:80/
http://*:80/
```
Az érvényes IP-címként vagy localhost nem felismert adatok helyettesítő karakterekként lesznek kezelve, amelyek az összes IPv4- és IPv6-címhez kötődnek. Vannak, akik szeretnek * vagy +-et használni, hogy pontosabban fogalmazzanak. Ha különböző hosztneveket szeretne különböző ASP.NET Core alkalmazásokhoz kötni ugyanazon a porton, használjon HTTP.sys vagy fordított proxy szervert.

Fordított proxykiszolgálók példái az IIS, a YARP, az Nginx és az Apache.
Hosztnév localhost portszámmal vagy loopback IP-cím portszámmal
```
http://localhost:5000/
http://127.0.0.1:5000/
http://[::1]:5000/
```
Ha localhost van megadva, Kestrel IPv4- és IPv6-visszacsatolási felületekhez is megpróbál csatlakozni. Ha a kért portot egy másik szolgáltatás használja bármelyik visszacsatolási felületen, Kestrel nem indul el. Ha bármelyik visszacsatolási felület más okból nem érhető el (leggyakrabban azért, mert az IPv6 nem támogatott), Kestrel figyelmeztetést naplóz.

Több URL-előtag is megadható pontosvesszővel (;) elválasztójellel:

http://*:5000;http://localhost:5001;https://hostname:5002

További információ: Konfiguráció felülbírálása.

HTTPS URL-előtagok

A HTTPS URL-előtagok csak akkor definiálhatók végpontokként, ha a HTTPS-végpont konfigurációjában egy alapértelmezett tanúsítvány van megadva. Használjon például KestrelServerOptions konfigurációt vagy konfigurációs fájlt, ahogyan az később kiderül ebben a cikkben .

További információ: HTTPS-konfigurálása.

Csak portok megadása

Az alkalmazások és tárolók gyakran csak egy portot kapnak a figyeléshez, például a 80-at, további korlátozások nélkül, például gazdagép vagy elérési út nélkül. HTTP_PORTS és HTTPS_PORTS olyan konfigurációs kulcsok, amelyek meghatározzák a Kestrel és HTTP.sys kiszolgálók figyelési portait. Ezek a kulcsok megadhatóak a DOTNET_ vagy ASPNETCORE_ előtagokkal definiált környezeti változókként, vagy közvetlenül bármely más konfigurációs bemeneten keresztül, például appsettings.json. Mindegyik a portértékek pontosvesszővel tagolt listája, ahogy az a következő példában is látható:

ASPNETCORE_HTTP_PORTS=80;8080
ASPNETCORE_HTTPS_PORTS=443;8081

Az előző példa a következő konfiguráció rövidített formátuma, amely meghatározza a sémát (HTTP vagy HTTPS), valamint bármely gazdagépet vagy IP-címet.

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

A HTTP_PORTS és HTTPS_PORTS konfigurációs kulcsok alacsonyabb prioritást élveznek, és felülírhatók a kódban közvetlenül megadott URL-ek vagy értékek által. A tanúsítványokat továbbra is külön kell konfigurálni a HTTPS kiszolgálóspecifikus mechanikáján keresztül.

Végpontok konfigurálása appsettings.json

Kestrel betölthet végpontokat egy IConfiguration-példányból. Alapértelmezés szerint Kestrel konfiguráció a Kestrel szakaszból töltődik be, a végpontok pedig Kestrel:Endpoints:

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpEndpoint": {
        "Url": "http://localhost:8080"
      }
    }
  }
}

Az előző példa:

Konfigurációs forrásként appsettings.json használ. Azonban bármilyen IConfiguration forrás használható.
Hozzáad egy MyHttpEndpoint nevű végpontot a 8080-as portra.

A végpontok JSON-nal való konfigurálásával kapcsolatos további információkért tekintse meg a jelen cikk későbbi szakaszait, amelyek a HTTPS - konfigurálásáról és a HTTP-protokollok appsettings.json konfigurálásáról szólnak.

Végpontok újratöltése konfigurációból

A végpontkonfiguráció újratöltése, ha a konfigurációs forrás módosítása alapértelmezés szerint engedélyezve van. A KestrelServerOptions.Configure(IConfiguration, Boolean)használatával letiltható.

Ha változás van jelezve, a következő lépések történnek:

Az új konfiguráció összehasonlítva van a régi konfigurációval, és a konfigurációmódosítás nélküli végpontok nem módosulnak.
Az eltávolított vagy módosított végpontok 5 másodpercet kapnak a feldolgozási kérelmek befejezéséhez és leállításához.
Új vagy módosított végpontok indulnak el.

A módosított végponthoz csatlakozó ügyfeleket a végpont újraindítása közben lehet leválasztani vagy elutasítani.

KonfigurációBetöltő

KestrelServerOptions.Configure egy KestrelConfigurationLoader-t ad vissza. A betöltő Endpoint(String, Action<EndpointConfiguration>) metódusa, amely egy konfigurált végpont beállításainak kiegészítésére használható:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    var kestrelSection = context.Configuration.GetSection("Kestrel");

    serverOptions.Configure(kestrelSection)
        .Endpoint("HTTPS", listenOptions =>
        {
            // ...
        });
});

KestrelServerOptions.ConfigurationLoader közvetlenül elérhető a meglévő rakodón való iterálás folytatásához, például a WebApplicationBuilder.WebHostáltal biztosított.

Az egyes végpontok konfigurációs szakasza a Endpoint metódus beállításai között érhető el, hogy az egyéni beállítások olvashatók legyenek.
KestrelServerOptions.Configure(IConfiguration) többször is meghívható, de csak az utolsó konfigurációt használja, kivéve, ha Load kifejezetten a korábbi példányokra van meghívva. Az alapértelmezett gazdagép nem hívja meg Load, hogy az alapértelmezett konfigurációs szakasz lecserélhető legyen.
KestrelConfigurationLoader KestrelServerOptions api-k Listen családját tükrözi Endpoint túlterhelésként, így a kód- és konfigurációvégpontok ugyanazon a helyen konfigurálhatók. Ezek a túlterhelések nem használnak neveket, és csak a konfiguráció alapértelmezett beállításait használják.

Végpontok konfigurálása a kódban

KestrelServerOptions metódusokat biztosít a végpontok kódban való konfigurálásához:

Ha a Listen és az UseUrls API-kat is egyszerre használják, a Listen végpontok felülbírálják a UseUrls végpontokat.

Kapcsolódás egy TCP-csatlakozóhoz

A Listen, ListenLocalhostés ListenAnyIP metódusok tcp-szoftvercsatornához kötődnek:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
    });
});

Az előző példa:

Az 5000-es és az 5001-es portnál figyelő végpontokat konfigurálja.
HTTPS-t konfigurál egy végponthoz a ListenOptions UseHttps bővítménymetódusával. További információ: HTTPS konfigurálása a kód.

Windows rendszeren az önaláírt tanúsítványok a New-SelfSignedCertificate PowerShell-parancsmaghasználatával hozhatók létre. A nem támogatott példát lásd: UpdateIISExpressSSLForChrome.ps1.

MacOS, Linux és Windows rendszeren a tanúsítványok OpenSSLhasználatával hozhatók létre.

Kötés Unix-szoftvercsatornához

Figyeljen egy Unix socketre ListenUnixSocket az Nginx teljesítményének javítása érdekében, ahogy az ebben a példában látható:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ListenUnixSocket("/tmp/kestrel-test.sock");
});

Az Nginx konfigurációs fájlban állítsa a server>location>proxy_pass bejegyzést http://unix:/tmp/{KESTREL SOCKET}:/;értékre. {KESTREL SOCKET} a ListenUnixSocket számára biztosított foglalat neve (például az előző példában kestrel-test.sock).
Győződjön meg arról, hogy az Nginx írhatja a foglalatot (például chmod go+w /tmp/kestrel-test.sock).

A végpont alapértelmezett beállításainak konfigurálása

ConfigureEndpointDefaults(Action<ListenOptions>) az egyes végpontokhoz futó konfigurációt adja meg. A ConfigureEndpointDefaults többszöri hívása felülírja az előző konfigurációt.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

A Listenáltal létrehozott végpontok, amelyeket a hívása előtt használtak a ConfigureEndpointDefaults esetén, nem alkalmazzák az alapértelmezett értékeket.

Dinamikus portkötés

Ha a portszám 0 van megadva, Kestrel dinamikusan kapcsolódik egy elérhető porthoz. Az alábbi példa bemutatja, hogyan határozható meg, hogy melyik port Kestrel van lekötve futásidőben.

app.Run(async (context) =>
{
    var serverAddressFeature = context.Features.Get<IServerAddressesFeature>();

    if (serverAddressFeature is not null)
    {
        var listenAddresses = string.Join(", ", serverAddressFeature.Addresses);

        // ...
    }
});

A port dinamikus kötése bizonyos esetekben nem érhető el:

KestrelServerOptions.ListenLocalhost
TCP-alapú HTTP/1.1, HTTP/2, és a QUIC-alapú HTTP/3 egybe kötése.

HTTPS konfigurálása

Kestrel támogatja a végpontok https használatával történő védelmét. A HTTPS-en keresztül küldött adatok titkosítása Transport Layer Security (TLS) használatával történik az ügyfél és a kiszolgáló közötti adatátvitel biztonságának növelése érdekében.

A HTTPS-hez TLS-tanúsítvány szükséges. A TLS-tanúsítvány a kiszolgálón van tárolva, és a Kestrel a használatára van konfigurálva. Egy alkalmazás helyi fejlesztési környezetben használhatja a ASP.NET Core HTTPS fejlesztési tanúsítványt. A fejlesztési tanúsítvány nincs telepítve nem fejletlen környezetekben. Éles környezetben a TLS-tanúsítványt explicit módon kell konfigurálni. Legalább egy alapértelmezett tanúsítványt kell megadni.

A HTTPS és a TLS-tanúsítvány konfigurálása a végpontok konfigurálásának módjától függ:

Ha URL-előtagok vagy csak portokat adnak meg a végpontok meghatározásához, a HTTPS csak akkor használható, ha a HTTPS-végpont konfigurációjában alapértelmezett tanúsítvány van megadva. Az alapértelmezett tanúsítvány az alábbi lehetőségek egyikével konfigurálható:
HTTPS konfigurálása appsettings.json
HTTPS konfigurálása kódban

HTTPS konfigurálása appsettings.json

A Kestrelszámára elérhető egy alapértelmezett HTTPS-alkalmazásbeállítások konfigurációs séma. Konfiguráljon több végpontot, köztük az URL-címeket és a használni kívánt tanúsítványokat egy lemezen lévő fájlból vagy egy tanúsítványtárolóból.

Minden olyan HTTPS-végpont, amely nem ad meg tanúsítványt (HttpsDefaultCert a következő példában) a Certificates:Default vagy a fejlesztési tanúsítványban meghatározott tanúsítványra kerül vissza.

A következő példa a appsettings.json, de bármely konfigurációs forrás használható:

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "HttpsInlineCertFile": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertAndKeyFile": {
        "Url": "https://localhost:5002",
        "Certificate": {
          "Path": "<path to .pem/.crt file>",
          "KeyPath": "<path to .key file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertStore": {
        "Url": "https://localhost:5003",
        "Certificate": {
          "Subject": "<subject; required>",
          "Store": "<certificate store; required>",
          "Location": "<location; defaults to CurrentUser>",
          "AllowInvalid": "<true or false; defaults to false>"
        }
      },
      "HttpsDefaultCert": {
        "Url": "https://localhost:5004"
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzőjeként szolgál. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásáról lásd az Azure Key Vault konfigurációs szolgáltatóját . A fejlesztési titkokat nem szabad éles vagy tesztelési célokra használni.

Sémajegyzetek

A végpontnevek kis- és nagybetűket nem érzékeny. A HTTPS és a Https például egyenértékűek.
A Url paraméter minden végponthoz szükséges. A paraméter formátuma megegyezik a legfelső szintű Urls konfigurációs paraméterével, azzal a kivételrel, hogy egyetlen értékre van korlátozva. Lásd a cikk URL-formátumait korábban.
Ezek a végpontok a felső szintű Urls konfigurációban definiált végpontokat helyettesítik ahelyett, hogy hozzáadják őket. A kódban Listen keresztül definiált végpontok a konfigurációs szakaszban meghatározott végpontokkal együtt halmozódnak.
A Certificate szakasz nem kötelező. Ha a Certificate szakasz nincs megadva, a rendszer a Certificates:Default definiált alapértelmezett értékeket használja. Ha nem érhetők el alapértelmezett értékek, a rendszer a fejlesztési tanúsítványt használja. Ha nincsenek alapértelmezett értékek, és a fejlesztési tanúsítvány nincs jelen, a kiszolgáló kivételt jelez, és nem indul el.
A Certificate szakasz több tanúsítványforrást is támogat.
Tetszőleges számú végpont definiálható a Configuration, feltéve, hogy nem okoznak portütközéseket.

Tanúsítványforrások

A tanúsítványcsomópontok számos forrásból származó tanúsítványok betöltésére konfigurálhatók:

A Path és Password a .pfx fájlok betöltésére szolgál.
Path, KeyPath és Password.pem/.crt és .key fájlok betöltéséhez.
Subject és Store a tanúsítványtárolóból való betöltéshez.

A Certificates:Default tanúsítvány például a következő módon adható meg:

"Default": {
  "Subject": "<subject; required>",
  "Store": "<cert store; required>",
  "Location": "<location; defaults to CurrentUser>",
  "AllowInvalid": "<true or false; defaults to false>"
}

Ügyféltanúsítványok konfigurálása a appsettings.json-ban

ClientCertificateMode az ügyféltanúsítványok viselkedésének konfigurálására szolgál.

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "ClientCertificateMode": "AllowCertificate",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token helyőrzőként szolgál a tanúsítvány jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. Tanúsítványjelszavak biztonságos tárolásához éles környezetben, lásd az Azure Key Vault konfigurációszolgáltatóját . A fejlesztési titkok nem használhatók éles vagy teszt környezetben.

Az alapértelmezett érték a ClientCertificateMode.NoCertificate, ahol Kestrel nem kér vagy igényel tanúsítványt az ügyféltől.

További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

Az SSL-/TLS-protokollok konfigurálása a appsettings.json

Az SSL-protokollok olyan protokollok, amelyek két társ, hagyományosan egy ügyfél és egy kiszolgáló közötti forgalom titkosítására és visszafejtésére szolgálnak.

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "SslProtocols": ["Tls12", "Tls13"],
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. Éles környezetben a tanúsítványjelszavak biztonságos tárolásához lásd: az Azure Key Vault konfigurációs szolgáltatót. Fejlesztési titkok nem használhatók éles vagy tesztelés során.

Az alapértelmezett érték (SslProtocols.None) miatt Kestrel az operációs rendszer alapértelmezett értékeit használva választja ki a legjobb protokollt. Ha nincs konkrét oka a protokoll kiválasztására, használja az alapértelmezett beállítást.

HTTPS konfigurálása kódban

A Listen API használatakor a ListenOptions UseHttps bővítménymetódusa elérhető a HTTPS konfigurálásához.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
    });
});

ListenOptions.UseHttps paraméterek:

filename egy tanúsítványfájl elérési útja és fájlneve az alkalmazás tartalomfájljait tartalmazó könyvtárhoz viszonyítva.
password az X.509-tanúsítványadatok eléréséhez szükséges jelszó.
configureOptions egy Action a HttpsConnectionAdapterOptionskonfigurálásához. A(z) ListenOptions-t adja vissza.
A storeName az a tanúsítványtár, amelyből a tanúsítvány betöltésre kerül.
subject a tanúsítvány tulajdonosának neve.
allowInvalid jelzi, hogy érvénytelen tanúsítványokat kell-e figyelembe venni, például önaláírt tanúsítványokat.
location a tárolási hely, ahonnan a tanúsítvány betölthető.
serverCertificate az X.509-tanúsítvány.

A UseHttps túlterhelések teljes listáját lásd: UseHttps.

Ügyféltanúsítványok konfigurálása kódban

ClientCertificateMode konfigurálja az ügyféltanúsítvány követelményeit.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
    });
});

Az alapértelmezett érték a NoCertificate, ahol Kestrel nem kér vagy igényel tanúsítványt az ügyféltől.

További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

HTTPS-alapértelmezett beállítások konfigurálása a kódban

ConfigureHttpsDefaults(Action<HttpsConnectionAdapterOptions>) megadja az egyes HTTPS-végpontokhoz futtatandó konfigurációs Action. Többszöri ConfigureHttpsDefaults hívás felülírja a korábbi Action példányokat az utolsó megadott Action-vel.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

Ahívása előtt Listen által létrehozott végpontok ConfigureHttpsDefaults nem alkalmazzák az alapértelmezett értékeket.

SSL-/TLS-protokollok konfigurálása kódban

Az SSL-protokollok olyan protokollok, amelyek két társ, hagyományosan egy ügyfél és egy kiszolgáló közötti forgalom titkosítására és visszafejtésére szolgálnak.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.SslProtocols = SslProtocols.Tls13;
    });
});

TLS-titkosítási csomagok szűrőjének konfigurálása kódban

Linuxon CipherSuitesPolicy használható a TLS-kézfogások kapcsolatonkénti szűrésére:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.OnAuthenticate = (context, sslOptions) =>
        {
            sslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(
                new[]
                {
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                    // ...
                });
        };
    });
});

Kiszolgálónév-jelzés konfigurálása

kiszolgálónév-jelzés (SNI) több tartomány üzemeltetésére is használható ugyanazon az IP-címen és porton. Az SNI az erőforrások megőrzésére használható egy kiszolgáló több helyének kiszolgálásával.

Az SNI működéséhez az ügyfél elküldi a biztonságos munkamenet állomásnevét a kiszolgálónak a TLS-kézfogás során, hogy a kiszolgáló a megfelelő tanúsítványt tudja biztosítani. Az ügyfél a mellékelt tanúsítványt használja a kiszolgálóval való titkosított kommunikációhoz a TLS-kézfogást követő biztonságos munkamenet során.

Minden webhelynek ugyanazon a Kestrel példányon kell futnia. Kestrel nem támogatja az IP-cím és a port megosztását több példány között fordított proxy nélkül.

Az SNI kétféleképpen konfigurálható:

Állítson be leképezést a gazdagépnevek és a HTTPS-beállítások között a Konfigurációalatt. A JSON például a appsettings.json fájlban.
Hozzon létre egy végpontot a kódban, és válasszon ki egy tanúsítványt a ServerCertificateSelector visszahíváshoz tartozó gazdagép név használatával.

Konfigurálja az SNI-t a appsettings.json-ban

Kestrel támogatja a konfigurációban definiált SNI-t. A végpontok olyan Sni objektummal konfigurálhatók, amely megfeleltetést tartalmaz a gazdagépnevek és a HTTPS-beállítások között. A kapcsolat gazdagépének neve megegyezik a beállításokkal, és a rendszer az adott kapcsolathoz használja őket.

A következő konfiguráció hozzáad egy MySniEndpoint nevű végpontot, amely az SNI használatával választja ki a HTTPS-beállításokat a gazdagép neve alapján:

{
  "Kestrel": {
    "Endpoints": {
      "MySniEndpoint": {
        "Url": "https://*",
        "SslProtocols": ["Tls11", "Tls12"],
        "Sni": {
          "a.example.org": {
            "Protocols": "Http1AndHttp2",
            "SslProtocols": ["Tls11", "Tls12", "Tls13"],
            "Certificate": {
              "Subject": "<subject; required>",
              "Store": "<certificate store; required>",
            },
            "ClientCertificateMode" : "NoCertificate"
          },
          "*.example.org": {
            "Certificate": {
              "Path": "<path to .pfx file>",
              "Password": "$CREDENTIAL_PLACEHOLDER$"
            }
          },
          "*": {
            // At least one subproperty needs to exist per SNI section or it
            // cannot be discovered via IConfiguration
            "Protocols": "Http1",
          }
        }
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzőjeként van használva. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. Az éles környezetben a tanúsítványjelszavak biztonságos tárolásához tekintse meg az Azure Key Vault konfigurációs szolgáltató beállításait . A fejlesztési titkok nem használhatók éles vagy tesztelési célokra.

AZ SNI által felülírható HTTPS-beállítások:

Certificate konfigurálja a tanúsítványforrás.
Protocols konfigurálja az engedélyezett HTTP-protokollokat.
SslProtocols konfigurálja az engedélyezett SSL-protokollokat.
ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

A gazdagép neve támogatja a helyettesítő karakterek egyeztetését:

Pontos egyezés. Például a a.example.org megegyezik a a.example.org-el.
Helyettesítő karakter előtag. Ha több helyettesítő karakter egyezés van, akkor a leghosszabb mintát választják ki. Például a *.example.org megegyezik a b.example.org-gyel és a c.example.org-vel.
Teljes helyettesítő karakter. * illeszkedik minden máshoz, beleértve azokat az ügyfeleket is, amelyek nem használnak SNI-t, és nem küldenek hosztnevet.

A rendszer a megfelelt SNI-konfigurációt alkalmazza a végpontra a kapcsolathoz, felülírva a végpont értékeit. Ha egy kapcsolat nem egyezik meg a konfigurált SNI-gazdagép nevével, a kapcsolat elutasításra kerül.

SNI konfigurálása kóddal

Kestrel számos visszahívási API-val támogatja az SNI-t:

ServerCertificateSelector
ServerOptionsSelectionCallback
TlsHandshakeCallbackOptions

SNI `ServerCertificateSelector`

Kestrel támogatja a SNI használatát a ServerCertificateSelector visszahíváson keresztül. A visszahívást kapcsolatonként egyszer hívjuk meg, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthassa a megfelelő tanúsítványt:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var subExampleCert = CertificateLoader.LoadFromStoreCert(
                "sub.example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var certs = new Dictionary<string, X509Certificate2>(
                StringComparer.OrdinalIgnoreCase)
            {
                ["localhost"] = localhostCert,
                ["example.com"] = exampleCert,
                ["sub.example.com"] = subExampleCert
            };

            httpsOptions.ServerCertificateSelector = (connectionContext, name) =>
            {
                if (name is not null && certs.TryGetValue(name, out var cert))
                {
                    return cert;
                }

                return exampleCert;
            };
        });
    });
});

SNI `ServerOptionsSelectionCallback`

Kestrel támogatja a további dinamikus TLS-konfigurációt a ServerOptionsSelectionCallback visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt és TLS-konfigurációt. Az alapértelmezett tanúsítványok és ConfigureHttpsDefaults nem használhatók ezzel a visszahívással.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps((stream, clientHelloInfo, state, cancellationToken) =>
            {
                if (string.Equals(clientHelloInfo.ServerName, "localhost",
                    StringComparison.OrdinalIgnoreCase))
                {
                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = localhostCert,
                            // Different TLS requirements for this host
                            ClientCertificateRequired = true
                        });
                }

                return new ValueTask<SslServerAuthenticationOptions>(
                    new SslServerAuthenticationOptions
                    {
                        ServerCertificate = exampleCert
                    });
            }, state: null!);
        });
    });
});

SNI `TlsHandshakeCallbackOptions`-val

Kestrel támogatja a további dinamikus TLS-konfigurációt a TlsHandshakeCallbackOptions.OnConnection visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt, a TLS-konfigurációt és más kiszolgálóbeállításokat. Az alapértelmezett tanúsítványok és ConfigureHttpsDefaults nem használhatók ezzel a visszahívással.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps(new TlsHandshakeCallbackOptions
            {
                OnConnection = context =>
                {
                    if (string.Equals(context.ClientHelloInfo.ServerName, "localhost",
                        StringComparison.OrdinalIgnoreCase))
                    {
                        // Different TLS requirements for this host
                        context.AllowDelayedClientCertificateNegotation = true;

                        return new ValueTask<SslServerAuthenticationOptions>(
                            new SslServerAuthenticationOptions
                            {
                                ServerCertificate = localhostCert
                            });
                    }

                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = exampleCert
                        });
                }
            });
        });
    });
});

HTTP-protokollok konfigurálása

Kestrel támogatja az összes gyakran használt HTTP-verziót. A végpontok konfigurálhatók különböző HTTP-verziók támogatására a HttpProtocols szám használatával, amely megadja az elérhető HTTP-verzióbeállításokat.

Egynél több HTTP-verzió támogatásához TLS szükséges. A TLS Application-Layer Protocol Negotiation (ALPN) kézfogás az ügyfél és a kiszolgáló közötti kapcsolati protokoll egyeztetésére szolgál, ha egy végpont több protokollt támogat.

`HttpProtocols` érték	Engedélyezett kapcsolati protokoll
`Http1`	Csak HTTP/1.1. TLS-sel vagy anélkül is használható.
`Http2`	csak HTTP/2. TLS nélkül csak akkor használható, ha az ügyfél támogatja a Korábbi tudás mód.
`Http3`	CSAK HTTP/3. TLS-t igényel. Előfordulhat, hogy az ügyfelet csak HTTP/3 használatára kell konfigurálni.
`Http1AndHttp2`	HTTP/1.1 és HTTP/2. A HTTP/2 megköveteli, hogy az ügyfél a HTTP/2-t válassza a TLS Application-Layer protokolltárgyaló (ALPN) kézfogás során; ellenkező esetben a kapcsolat alapértelmezés szerint HTTP/1.1.
`Http1AndHttp2AndHttp3`	HTTP/1.1, HTTP/2 és HTTP/3. Az első ügyfélkérés általában HTTP/1.1 vagy HTTP/2 protokollt használ, és a `alt-svc` válaszfejléc kéri az ügyfelet, hogy frissítsen HTTP/3-ra. A HTTP/2 és a HTTP/3 használatához TLS szükséges; ellenkező esetben a kapcsolat alapértelmezés szerint HTTP/1.1.

Egy végpont alapértelmezett protokollértéke HttpProtocols.Http1AndHttp2.

TLS-korlátozások HTTP/2-hez:

TLS 1.2-es vagy újabb verzió
Az újratárgyalás le van tiltva
Tömörítés letiltva
Rövid élettartamú kulcscsere minimális méretei:
- Elliptikus görbe Diffie-Hellman (ECDHE) [RFC4492]: legalább 224 bit
- Véges mező Diffie-Hellman (DHE) [TLS12]: legalább 2048 bit
A titkosítási csomag nem tiltott.

Az alapértelmezett beállítás szerint a TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 [TLS-ECDHE] támogatja a P-256 elliptikus görbét [FIPS186].

HTTP-protokollok konfigurálása a appsettings.json

Az alábbi appsettings.json példa a HTTP/1.1 kapcsolati protokollt hozza létre egy adott végponthoz:

{
  "Kestrel": {
    "Endpoints": {
      "HttpsDefaultCert": {
        "Url": "https://localhost:5001",
        "Protocols": "Http1"
      }
    }
  }
}

Az alapértelmezett protokoll a Kestrel:EndpointDefaults szakaszban konfigurálható. Az alábbi appsettings.json példa a HTTP/1.1 protokollt hozza létre az összes végpont alapértelmezett kapcsolati protokolljaként:

{
  "Kestrel": {
    "EndpointDefaults": {
      "Protocols": "Http1"
    }
  }
}

A konfiguráció által beállított kód felülbírálási értékekben megadott protokollok.

HTTP-protokollok konfigurálása kódban

ListenOptions.Protocols a HttpProtocols enumerálási protokollok megadására szolgál.

Az alábbi példa a HTTP/1.1, HTTP/2 és HTTP/3 kapcsolatok végpontjait konfigurálja a 8000-s porton. A kapcsolatokat a TLS egy megadott tanúsítvánnyal védi:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
    });
});

Lásd még:

Kestrel webkiszolgáló ASP.NET Core
ASP.NET Core Kestrel webkiszolgáló beállításainak konfigurálása

ASP.NET alapprojektek úgy vannak konfigurálva, hogy 5000–5300 közötti véletlenszerű HTTP-porthoz és 7000–7300 közötti véletlenszerű HTTPS-porthoz kössenek. Ez az alapértelmezett konfiguráció a létrehozott Properties/launchSettings.json fájlban van megadva, és felül lehet bírálni. Ha nincs megadva port, akkor a Kestrel kapcsolódik a http://localhost:5000-hez.

Adja meg az URL-címeket a következővel:

ASPNETCORE_URLS környezeti változó.
--urls parancssori argumentum.
urls host konfigurációs kulcs.
UseUrls bővítménymetódus.

Az e megközelítések használatával megadott érték lehet egy vagy több HTTP- és HTTPS-végpont (HTTPS, ha van alapértelmezett tanúsítvány). Konfigurálja az értéket pontosvesszővel tagolt listaként (például "Urls": "http://localhost:8000;http://localhost:8001").

További információt ezekről a megközelítésekről a következő helyeken talál: kiszolgálói URL-címek és konfiguráció felülbírálása.

Létrejön egy fejlesztési tanúsítvány:

Amikor a .NET SDK telepítve van.
A dev-certs eszköz egy tanúsítvány létrehozásához használható.

A fejlesztési tanúsítvány csak a tanúsítványt létrehozó felhasználó számára érhető el. Egyes böngészők explicit engedélyt igényelnek a helyi fejlesztési tanúsítvány megbízhatóságához.

A projektsablonok alapértelmezés szerint HTTPS-alapú futtatásra konfigurálják az alkalmazásokat, és tartalmazzák HTTPS-átirányítást és a HSTS-támogatást.

Hívja meg a(z) Listen vagy ListenUnixSocket metódust a KestrelServerOptions URL-előtagjai és portjai konfigurálására Kestrelszámára.

UseUrls, a --urls parancssori argumentum, urls gazdagép konfigurációs kulcsa és a ASPNETCORE_URLS környezeti változó szintén működik, de a jelen szakaszban később feljegyzett korlátozásokkal rendelkezik (a HTTPS-végpont konfigurációja esetén egy alapértelmezett tanúsítványnak kell rendelkezésre állnia).

KestrelServerOptions konfiguráció:

ConfigureEndpointDefaults

ConfigureEndpointDefaults(Action<ListenOptions>) egy konfigurációs Action határoz meg, amely minden megadott végponthoz futtatható. Ha többször hívjuk a(z) ConfigureEndpointDefaults-t, a korábbi Action-eket az utoljára megadott Action helyettesíti.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

Ahívása előtt Listen által létrehozott végpontok ConfigureEndpointDefaults nem alkalmazzák az alapértelmezett értékeket.

Konfigurálás(IConfiguration)

Lehetővé teszi, hogy Kestrel betöltse a végpontokat egy IConfiguration-ből. A konfigurációt a Kestrelkonfigurációs szakaszára kell korlátozni. A Configure(IConfiguration, bool) túlterhelés a végpontok újratöltésének engedélyezésére használható, amikor a konfigurációs forrás megváltozik.

Alapértelmezés szerint Kestrel konfiguráció a Kestrel szakaszból töltődik be, és a módosítások újratöltése engedélyezve van:

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "Https": {
        "Url": "https://localhost:5001"
      }
    }
  }
}

Ha a konfiguráció újratöltése engedélyezve van, és a rendszer módosítást jelez, a következő lépéseket kell végrehajtania:

Az új konfiguráció a régihez hasonlítható, a konfigurációmódosítás nélküli végpontok nem módosulnak.
Az eltávolított vagy módosított végpontok 5 másodpercet kapnak a feldolgozási kérelmek befejezéséhez és leállításához.
Új vagy módosított végpontok indulnak el.

A módosított végponthoz csatlakozó ügyfeleket a végpont újraindítása közben lehet leválasztani vagy elutasítani.

HttpsDefaults konfigurálása

ConfigureHttpsDefaults(Action<HttpsConnectionAdapterOptions>) meghatározza az egyes HTTPS-végpontokhoz tartozó konfigurációt a futtatáshoz Action. A ConfigureHttpsDefaults többszöri hívása lecseréli a korábbi Action-eket az utoljára megadott Action-re.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

A Listenhívásával létrehozott végpontokra nem vonatkoznak az alapértelmezett értékek, ha a előtt hívjuk a ConfigureHttpsDefaults-at.

ListenOptions.UseHttps

Konfigurálja a Kestrel HTTPS használatára.

ListenOptions.UseHttps bővítmények:

UseHttps: Konfigurálja a Kestrel, hogy https-t használjon az alapértelmezett tanúsítvánnyal. Kivételt eredményez, ha nincs alapértelmezett tanúsítvány konfigurálva.
UseHttps(string fileName)
UseHttps(string fileName, string password)
UseHttps(string fileName, string password, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(StoreName storeName, string subject)
UseHttps(StoreName storeName, string subject, bool allowInvalid)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(X509Certificate2 serverCertificate)
UseHttps(X509Certificate2 serverCertificate, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(Action<HttpsConnectionAdapterOptions> configureOptions)

ListenOptions.UseHttps paraméterek:

filename egy tanúsítványfájl elérési útja és fájlneve az alkalmazás tartalomfájljait tartalmazó könyvtárhoz viszonyítva.
password az X.509-tanúsítványadatok eléréséhez szükséges jelszó.
configureOptions egy Action a HttpsConnectionAdapterOptionskonfigurálásához. A ListenOptions-et adja vissza.
storeName a tanúsítványtár, amelyből betöltendő a tanúsítvány.
subject a tanúsítvány tulajdonosának neve.
allowInvalid jelzi, hogy érvénytelen tanúsítványokat kell-e figyelembe venni, például önaláírt tanúsítványokat.
Az location a tárhely, ahonnan a tanúsítványt betöltjük.
serverCertificate az X.509-tanúsítvány.

Éles környezetben a HTTPS-t explicit módon kell konfigurálni. Legalább egy alapértelmezett tanúsítványt kell megadni.

Ha a tanúsítványokat lemezről olvassák, nem pedig a Windows Tanúsítványtároló , a tárolókönyvtárnak megfelelő engedélyekkel kell rendelkeznie a jogosulatlan hozzáférés megakadályozásához.

A következőkben ismertetett támogatott konfigurációk:

Nincs konfiguráció
Az alapértelmezett tanúsítvány cseréje a konfigurációból
Az alapértelmezett értékek módosítása a kódban

Nincs konfiguráció

Kestrel figyel http://localhost:5000.

Az alapértelmezett tanúsítvány cseréje a konfigurációból

Alapértelmezett HTTPS-alkalmazásbeállítások konfigurációs sémája áll rendelkezésre Kestrelszámára. Konfiguráljon több végpontot, köztük az URL-címeket és a használni kívánt tanúsítványokat egy lemezen lévő fájlból vagy egy tanúsítványtárolóból.

Az alábbi appsettings.json példában:

Állítsa AllowInvalid-t true-re az érvénytelen tanúsítványok (például önaláírt tanúsítványok) használatának engedélyezéséhez.
Minden olyan HTTPS-végpont, amely nem ad meg tanúsítványt (HttpsDefaultCert a következő példában) a Certificates:Default vagy a fejlesztési tanúsítvány alatt meghatározott tanúsítványra kerül vissza.

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "HttpsInlineCertFile": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertAndKeyFile": {
        "Url": "https://localhost:5002",
        "Certificate": {
          "Path": "<path to .pem/.crt file>",
          "KeyPath": "<path to .key file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertStore": {
        "Url": "https://localhost:5003",
        "Certificate": {
          "Subject": "<subject; required>",
          "Store": "<certificate store; required>",
          "Location": "<location; defaults to CurrentUser>",
          "AllowInvalid": "<true or false; defaults to false>"
        }
      },
      "HttpsDefaultCert": {
        "Url": "https://localhost:5004"
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent helyőrzőként használják az egyes tanúsítványok jelszava számára. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. Éles környezetben a tanúsítványjelszavak biztonságos tárolásához tekintse meg az Azure Key Vault konfigurációs szolgáltatóját . A fejlesztési titkok nem használhatók éles vagy tesztkörnyezetben.

Sémajegyzetek:

A végpontok neve kis- és nagybetűket nem különbözteti meg. A HTTPS és a Https például egyenértékűek.
A Url paraméter minden végponthoz szükséges. A paraméter formátuma megegyezik a legfelső szintű Urls konfigurációs paraméterével, azzal a kivételrel, hogy egyetlen értékre van korlátozva.
Ezek a végpontok a felső szintű Urls konfigurációban definiált végpontokat helyettesítik ahelyett, hogy hozzáadják őket. A kódban Listen keresztül definiált végpontok a konfigurációs szakaszban meghatározott végpontokkal együtt halmozódnak.
A Certificate szakasz nem kötelező. Ha a Certificate szakasz nincs megadva, a rendszer a Certificates:Default definiált alapértelmezett értékeket használja. Ha nem érhetők el alapértelmezett értékek, a rendszer a fejlesztési tanúsítványt használja. Ha nincsenek alapértelmezett értékek, és a fejlesztési tanúsítvány nincs jelen, a kiszolgáló kivételt jelez, és nem indul el.
A Certificate szakasz több tanúsítványforrásttámogat.
Bármilyen számú végpont definiálható konfigurációs, ha nem okoznak portütközéseket.

Tanúsítványforrások

A tanúsítványcsomópontok számos forrásból származó tanúsítványok betöltésére konfigurálhatók:

Path és Password.pfx fájlok betöltéséhez.
Path, KeyPath és Password.pem/.crt és .key fájlok betöltéséhez.
Subject és Store a tanúsítványtárolóból való betöltéshez.

A Certificates:Default tanúsítvány például a következő módon adható meg:

"Default": {
  "Subject": "<subject; required>",
  "Store": "<cert store; required>",
  "Location": "<location; defaults to CurrentUser>",
  "AllowInvalid": "<true or false; defaults to false>"
}

Konfiguráció Betöltő

Configure(IConfiguration) egy Endpoint(String, Action<EndpointConfiguration>) metódussal rendelkező KestrelConfigurationLoader ad vissza, amely egy konfigurált végpont beállításainak kiegészítésére használható:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    var kestrelSection = context.Configuration.GetSection("Kestrel");

    serverOptions.Configure(kestrelSection)
        .Endpoint("HTTPS", listenOptions =>
        {
            // ...
        });
});

KestrelServerOptions.ConfigurationLoader közvetlenül hozzáférhető ahhoz, hogy folytassa az ismétlőleges műveleteket a meglévő betöltőn, például az WebApplicationBuilder.WebHostáltal biztosítotton.

Az egyes végpontok konfigurációs szakasza a Endpoint metódus beállításai között érhető el, hogy az egyéni beállítások olvashatók legyenek.
Előfordulhat, hogy több konfiguráció is betöltődik, ha ismét meghívja Configure(IConfiguration) egy másik szakaszsal. A rendszer csak az utolsó konfigurációt használja, hacsak a Load nem kerül kifejezetten hívásra a korábbi példányok esetében. A metacsomag nem hívja meg Load, hogy az alapértelmezett konfigurációs szakasz lecserélhető legyen.
KestrelConfigurationLoader az API-k Listen családját KestrelServerOptionsEndpoint túlterhelésként tükrözi, így a kód- és konfigurációvégpontok ugyanazon a helyen konfigurálhatók. Ezek a túlterhelések nem használnak neveket, és csak a konfiguráció alapértelmezett beállításait használják.

Az alapértelmezett értékek módosítása a kódban

ConfigureEndpointDefaults és ConfigureHttpsDefaults az ListenOptions és a HttpsConnectionAdapterOptionsalapértelmezett beállításainak módosítására használható, beleértve az előző forgatókönyvben megadott alapértelmezett tanúsítvány felülírását is. A végpontok konfigurálása előtt ConfigureEndpointDefaults és ConfigureHttpsDefaults kell meghívni.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // ...
    });

    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // ...
    });
});

Végpontok konfigurálása kiszolgálónév-jelzéssel

kiszolgálónév-jelzés (SNI) több tartomány üzemeltetésére is használható ugyanazon az IP-címen és porton. Az SNI működéséhez az ügyfél elküldi a biztonságos munkamenet állomásnevét a kiszolgálónak a TLS-kézfogás során, hogy a kiszolgáló a megfelelő tanúsítványt tudja biztosítani. Az ügyfél a mellékelt tanúsítványt használja a kiszolgálóval való titkosított kommunikációhoz a TLS-kézfogást követő biztonságos munkamenet során.

Az SNI kétféleképpen konfigurálható:

Hozzon létre egy végpontot a kódban, és a ServerCertificateSelector visszahívás segítségével válasszon ki egy tanúsítványt a gazdagép neve alapján.
Konfigurálj egy leképezést a hosztnevek és a HTTPS-beállítások között a Konfigurációs menüben. A JSON például a appsettings.json fájlban.

SNI `ServerCertificateSelector`-val

Kestrel támogatja az SNI-t a ServerCertificateSelector visszahíváson keresztül. A visszahívást kapcsolatonként egyszer hívjuk meg, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthassa a megfelelő tanúsítványt:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var subExampleCert = CertificateLoader.LoadFromStoreCert(
                "sub.example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var certs = new Dictionary<string, X509Certificate2>(
                StringComparer.OrdinalIgnoreCase)
            {
                ["localhost"] = localhostCert,
                ["example.com"] = exampleCert,
                ["sub.example.com"] = subExampleCert
            };

            httpsOptions.ServerCertificateSelector = (connectionContext, name) =>
            {
                if (name is not null && certs.TryGetValue(name, out var cert))
                {
                    return cert;
                }

                return exampleCert;
            };
        });
    });
});

SNI `ServerOptionsSelectionCallback`-val

Kestrel támogatja a további dinamikus TLS-konfigurációt a ServerOptionsSelectionCallback visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt és TLS-konfigurációt. Ez a visszahívás nem használja az alapértelmezett tanúsítványokat és a ConfigureHttpsDefaults elemet.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps((stream, clientHelloInfo, state, cancellationToken) =>
            {
                if (string.Equals(clientHelloInfo.ServerName, "localhost",
                    StringComparison.OrdinalIgnoreCase))
                {
                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = localhostCert,
                            // Different TLS requirements for this host
                            ClientCertificateRequired = true
                        });
                }

                return new ValueTask<SslServerAuthenticationOptions>(
                    new SslServerAuthenticationOptions
                    {
                        ServerCertificate = exampleCert
                    });
            }, state: null!);
        });
    });
});

SNI `TlsHandshakeCallbackOptions`-vel

Kestrel támogatja a további dinamikus TLS-konfigurációt a TlsHandshakeCallbackOptions.OnConnection visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt, a TLS-konfigurációt és más kiszolgálóbeállításokat. Ez a visszahívás nem használja az alapértelmezett tanúsítványokat és a ConfigureHttpsDefaults-t.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps(new TlsHandshakeCallbackOptions
            {
                OnConnection = context =>
                {
                    if (string.Equals(context.ClientHelloInfo.ServerName, "localhost",
                        StringComparison.OrdinalIgnoreCase))
                    {
                        // Different TLS requirements for this host
                        context.AllowDelayedClientCertificateNegotation = true;

                        return new ValueTask<SslServerAuthenticationOptions>(
                            new SslServerAuthenticationOptions
                            {
                                ServerCertificate = localhostCert
                            });
                    }

                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = exampleCert
                        });
                }
            });
        });
    });
});

SNI konfigurációban

A következő konfiguráció hozzáad egy MySniEndpoint nevű végpontot, amely az SNI használatával választja ki a HTTPS-beállításokat a gazdagép neve alapján:

{
  "Kestrel": {
    "Endpoints": {
      "MySniEndpoint": {
        "Url": "https://*",
        "SslProtocols": ["Tls11", "Tls12"],
        "Sni": {
          "a.example.org": {
            "Protocols": "Http1AndHttp2",
            "SslProtocols": ["Tls11", "Tls12", "Tls13"],
            "Certificate": {
              "Subject": "<subject; required>",
              "Store": "<certificate store; required>",
            },
            "ClientCertificateMode" : "NoCertificate"
          },
          "*.example.org": {
            "Certificate": {
              "Path": "<path to .pfx file>",
              "Password": "$CREDENTIAL_PLACEHOLDER$"
            }
          },
          "*": {
            // At least one subproperty needs to exist per SNI section or it
            // cannot be discovered via IConfiguration
            "Protocols": "Http1",
          }
        }
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent helyőrzőként használják az egyes tanúsítványok jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásához lásd az Azure Key Vault konfigurációs szolgáltatóját . A fejlesztési titkok nem használhatók éles környezetben vagy tesztelési célokra.

AZ SNI által felülírható HTTPS-beállítások:

Certificate konfigurálja a tanúsítványforrás.
Protocols konfigurálja az engedélyezett HTTP-protokollokat.
SslProtocols konfigurálja az engedélyezett SSL-protokollokat.
ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

A gazdagép neve támogatja a helyettesítő karakterek egyeztetését:

Pontos egyezés. Például a.example.org megfelel a.example.org-nek.
Különleges karakter előtag. Ha több egyezés van helyettesítő karakterrel, akkor a leghosszabb mintát választják ki. *.example.org megegyezik b.example.org és c.example.org-vel.
Teljes helyettesítő karakter. * megegyezik mindennel, beleértve azokat a klienseket is, amelyek nem használnak SNI-t, és nem küldenek hosztnevet.

SNI-követelmények

Minden webhelynek ugyanazon a Kestrel példányon kell futnia. Kestrel nem támogatja az IP-cím és a portok megosztását több példányok között fordított proxy nélkül.

SSL-/TLS-protokollok

Az SSL-protokollok olyan protokollok, amelyek két társ, hagyományosan egy ügyfél és egy kiszolgáló közötti forgalom titkosítására és visszafejtésére szolgálnak.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.SslProtocols = SslProtocols.Tls13;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "SslProtocols": ["Tls12", "Tls13"],
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolására vonatkozó információkért lásd az Azure Key Vault konfigurációszolgáltatóját . A fejlesztési titkok nem használhatók éles környezetben vagy tesztelésre.

Ügyféltanúsítványok

ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "ClientCertificateMode": "AllowCertificate",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzőjeként van használva. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásához lásd az Azure Key Vault konfigurációszolgáltatóját .

Az alapértelmezett érték ClientCertificateMode.NoCertificate, ahol Kestrel nem kér vagy igényel tanúsítványt az ügyféltől.

További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

Kapcsolatnaplózás

Hívja meg UseConnectionLogging, hogy hibakeresési szintű naplókat bocsátjon ki egy kapcsolat bájtszintű kommunikációjához. A kapcsolatnaplózás hasznos az alacsony szintű kommunikációval kapcsolatos problémák elhárításához, például a TLS titkosítása és a proxyk mögött. Ha UseConnectionLoggingUseHttpselé kerül, a rendszer titkosított forgalmat naplóz. Ha UseConnectionLoggingUseHttpsután kerül, a rendszer naplózza a visszafejtett forgalmat. Ez a beépített csatlakozási köztes szoftver.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseConnectionLogging();
    });
});

Kötés TCP-szoftvercsatornához

A Listen metódus egy TCP-szoftvercsatornához kapcsolódik, és egy beállítási lambda engedélyezi az X.509-tanúsítványkonfigurációt:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
    });
});

Ez a példa a HTTPS-t konfigurálja egy végponthoz ListenOptions. Ugyanezzel az API-val konfigurálhat más Kestrel beállításokat adott végpontokhoz.

Windows rendszeren az önaláírt tanúsítványok a New-SelfSignedCertificate PowerShell-parancsmaghasználatával hozhatók létre. Ehhez nem támogatott példát lásd: UpdateIISExpressSSLForChrome.ps1.

MacOS, Linux és Windows rendszeren a tanúsítványok OpenSSLhasználatával hozhatók létre.

Kötés egy Unix sockethez

Használjon Unix socketet ListenUnixSocket az Nginx teljesítményének javítása érdekében, ahogy az ebben a példában látható:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ListenUnixSocket("/tmp/kestrel-test.sock");
});

Az Nginx konfigurációs fájlban állítsa a server>location>proxy_pass bejegyzést http://unix:/tmp/{KESTREL SOCKET}:/;értékre. {KESTREL SOCKET} a ListenUnixSocket számára biztosított foglalat neve (például az előző példában kestrel-test.sock).
Győződjön meg arról, hogy a foglalat írható az Nginx által (például chmod go+w /tmp/kestrel-test.sock).

0 port

Ha a portszám 0 van megadva, Kestrel dinamikusan kapcsolódik egy elérhető porthoz. Az alábbi példa bemutatja, hogyan határozható meg, hogy melyik porthoz kapcsolódik a Kestrel futásidőben.

app.Run(async (context) =>
{
    var serverAddressFeature = context.Features.Get<IServerAddressesFeature>();

    if (serverAddressFeature is not null)
    {
        var listenAddresses = string.Join(", ", serverAddressFeature.Addresses);

        // ...
    }
});

A port dinamikus kötése bizonyos esetekben nem érhető el:

ListenLocalhost
TCP-alapú HTTP/1.1 vagy HTTP/2, valamint a QUIC-alapú HTTP/3 együttes kötése.

Korlátozások

A végpontok konfigurálása a következő módszerekkel:

UseUrls
--urls parancssori argumentum
urls gazdagép konfigurációs kulcs
ASPNETCORE_URLS környezeti változó

Ezek a módszerek a Kestrelkívüli kiszolgálókon való kódmunkához hasznosak. Vegye figyelembe azonban a következő korlátozásokat:

A HTTPS csak akkor használható ezekkel a módszerekkel, ha a HTTPS-végpont konfigurációjában egy alapértelmezett tanúsítvány van megadva (például KestrelServerOptions konfigurációval vagy konfigurációs fájllal, ahogyan a cikk korábbi részében látható).
A Listen és a UseUrls megközelítés egyidejű használata esetén a Listen végpontok felülbírálják a UseUrls végpontokat.

IIS-végpont konfigurálása

Az IIS használatakor az URL-kötéseket, amelyek felülírják az IIS kötéseit, a Listen vagy a UseUrlsállítja be. További információ: ASP.NET Core Module.

ListenOptions.Protocols

A Protocols tulajdonság létrehozza a kapcsolati végponton vagy a kiszolgálón engedélyezett HTTP-protokollokat (HttpProtocols). Rendeljen hozzá egy értéket a Protocols tulajdonsághoz a HttpProtocols enum-ból.

`HttpProtocols` számérték	Engedélyezett kapcsolati protokoll
`Http1`	Csak HTTP/1.1. TLS-sel vagy anélkül is használható.
`Http2`	CSAK HTTP/2. TLS nélkül csak akkor használható, ha az ügyfél támogatja a Korábbi tudás mód.
`Http3`	Csak HTTP/3. TLS-t igényel. Előfordulhat, hogy az ügyfelet csak HTTP/3 használatára kell konfigurálni.
`Http1AndHttp2`	HTTP/1.1 és HTTP/2. A HTTP/2 megköveteli, hogy az ügyfél az HTTP/2-t válassza a TLS Application-Layer Protokoll Tárgyalás (ALPN) kézfogás folyamatában; ellenkező esetben, a kapcsolat alapértelmezés szerint HTTP/1.1.
`Http1AndHttp2AndHttp3`	HTTP/1.1, HTTP/2 és HTTP/3. Az első ügyfélkérés általában HTTP/1.1 vagy HTTP/2 protokollt használ, és a `alt-svc` válaszfejléc kéri az ügyfelet, hogy frissítsen HTTP/3-ra. A HTTP/2 és a HTTP/3 használatához TLS szükséges; ellenkező esetben a kapcsolat alapértelmezés szerint HTTP/1.1.

A végpontok alapértelmezett ListenOptions.Protocols értéke HttpProtocols.Http1AndHttp2.

TLS-korlátozások HTTP/2-hez:

TLS 1.2-es vagy újabb verzió
Az újratárgyalás le van tiltva
Tömörítés letiltva
Rövid élettartamú kulcscsere minimális méretei:
- Elliptikus görbe Diffie-Hellman (ECDHE) [RFC4492]: legalább 224 bit
- Véges mező Diffie-Hellman (DHE) [TLS12]: legalább 2048 bit
A titkosítási csomag nem tiltott.

TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 [TLS-ECDHE] az elliptikus P-256 görbével [FIPS186] alapértelmezés szerint támogatott.

Az alábbi példa HTTP/1.1 és HTTP/2 kapcsolatokat engedélyez a 8000-s porton. A kapcsolatokat a TLS egy megadott tanúsítvánnyal védi:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
    });
});

Linuxon CipherSuitesPolicy használható a TLS-kézfogások kapcsolatonkénti szűrésére:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.OnAuthenticate = (context, sslOptions) =>
        {
            sslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(
                new[]
                {
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                    // ...
                });
        };
    });
});

Kapcsolat köztes szoftvere

Az egyéni kapcsolatközvetítvek szükség esetén kapcsolatonként szűrhetik a TLS-kézfogásokat adott rejtjelek esetében.

Az alábbi példa NotSupportedException ad minden olyan titkosítási algoritmushoz, amelyet az alkalmazás nem támogat. Másik lehetőségként definiálhatja és összehasonlíthatja a ITlsHandshakeFeature.CipherAlgorithm az elfogadható titkosítási csomagok listájával.

A rendszer nem használ titkosítást CipherAlgorithmType.Null titkosítási algoritmussal.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");

        listenOptions.Use((context, next) =>
        {
            var tlsFeature = context.Features.Get<ITlsHandshakeFeature>()!;

            if (tlsFeature.CipherAlgorithm == CipherAlgorithmType.Null)
            {
                throw new NotSupportedException(
                    $"Prohibited cipher: {tlsFeature.CipherAlgorithm}");
            }

            return next();
        });
    });
});

A HTTP-protokoll beállítása konfigurációból

Alapértelmezés szerint Kestrel konfiguráció a Kestrel szakaszból töltődik be. Az alábbi appsettings.json példa a HTTP/1.1 protokollt hozza létre az összes végpont alapértelmezett kapcsolati protokolljaként:

{
  "Kestrel": {
    "EndpointDefaults": {
      "Protocols": "Http1"
    }
  }
}

Az alábbi appsettings.json példa a HTTP/1.1 kapcsolati protokollt hozza létre egy adott végponthoz:

{
  "Kestrel": {
    "Endpoints": {
      "HttpsDefaultCert": {
        "Url": "https://localhost:5001",
        "Protocols": "Http1"
      }
    }
  }
}

A konfiguráció által beállított kód felülbírálási értékekben megadott protokollok.

URL-előtagok

Ha UseUrls, --urls parancssori argumentumot, urls gazdagép konfigurációs kulcsát vagy ASPNETCORE_URLS környezeti változót használ, az URL-előtagok az alábbi formátumok bármelyikében lehetnek.

Csak a HTTP URL-előtagok érvényesek. Kestrel nem támogatja a HTTPS-t az URL-kötések UseUrlshasználatával történő konfigurálásakor.

IPv4-cím portszámmal
```
http://65.55.39.10:80/
```
0.0.0.0 egy speciális eset, amely az összes IPv4-címhez kötődik.
IPv6-cím portszámmal
```
http://[0:0:0:0:0:ffff:4137:270a]:80/
```
[::] az IPv4 0.0.0.0IPv6-megfelelője.
Hostnév portszámmal
```
http://contoso.com:80/
http://*:80/
```
A hostnevek, *és +, nem különlegesek. Az, ami nem tekinthető érvényes IP-címnek, vagy localhost, az összes IPv4- és IPv6-IP-címhez kapcsolódik. Ha különböző gazdagépneveket szeretne ugyanazon a porton különböző ASP.NET Core-alkalmazásokhoz kötni, használjon HTTP.sys-t vagy fordított proxykiszolgálót. A fordított proxykiszolgálók például az IIS, az Nginx vagy az Apache.

Figyelmeztetés

A fordított proxykonfigurációban való üzemeltetéshez gazdagépszűrésiszükséges.
Gazdagép localhost neve portszámmal vagy visszacsatolási IP-cím portszámmal
```
http://localhost:5000/
http://127.0.0.1:5000/
http://[::1]:5000/
```
Ha localhost van megadva, Kestrel IPv4- és IPv6-visszacsatolási felületekhez is megpróbál csatlakozni. Ha a kért portot egy másik szolgáltatás használja bármelyik visszacsatolási felületen, Kestrel nem indul el. Ha bármelyik visszacsatolási felület más okból nem érhető el (leggyakrabban azért, mert az IPv6 nem támogatott), Kestrel figyelmeztetést naplóz.

http://localhost:5000
https://localhost:5001 (helyi fejlesztési tanúsítvány esetén)

Adja meg az URL-címeket a következővel:

ASPNETCORE_URLS környezeti változó.
--urls parancssori argumentum.
urls gazdagép konfigurációs kulcs.
UseUrls bővítménymetódus.

További információ ezekről a módszerekről: szerver URL-ek és konfiguráció felülírása.

Létrejön egy fejlesztési tanúsítvány:

Amikor a .NET SDK telepítve van.
A dev-certs eszköz egy tanúsítvány létrehozásához használható.

A projektsablonok alapértelmezés szerint HTTPS-alapú futtatásra konfigurálják az alkalmazásokat, és tartalmazzák HTTPS-átirányítást és a HSTS-támogatást.

Hívja meg a Listen vagy ListenUnixSocket függvényeket a KestrelServerOptions URL-előtagjainak és portjainak konfigurálásához a Kestrelszámára.

KestrelServerOptions konfiguráció:

Végpont Alapértelmezések Beállítása

ConfigureEndpointDefaults(Action<ListenOptions>) egy konfigurációs Action határoz meg, amely minden megadott végponthoz futtatható. A ConfigureEndpointDefaults többszöri hívása az utolsó megadott Action-vel helyettesíti a korábbi Action-eket.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

Ahívása előtt Listen által létrehozott végpontok ConfigureEndpointDefaults nem alkalmazzák az alapértelmezett értékeket.

Konfigurálás(IConfiguration)

Lehetővé teszi, hogy Kestrel betöltse a végpontokat a(z) IConfiguration-ből. A konfigurációt a Kestrelkonfigurációs szakaszára kell korlátozni. A Configure(IConfiguration, bool) túlterhelés a végpontok újratöltésének engedélyezésére használható, amikor a konfigurációs forrás megváltozik.

Alapértelmezés szerint Kestrel konfiguráció a Kestrel szakaszból töltődik be, és a módosítások újratöltése engedélyezve van:

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "Https": {
        "Url": "https://localhost:5001"
      }
    }
  }
}

Ha a konfiguráció újratöltése engedélyezve van, és a rendszer módosítást jelez, a következő lépéseket kell végrehajtania:

Az új konfiguráció a régihez hasonlítható, a konfigurációmódosítás nélküli végpontok nem módosulnak.
Az eltávolított vagy módosított végpontok 5 másodpercet kapnak a feldolgozási kérelmek befejezéséhez és leállításához.
Új vagy módosított végpontok indulnak el.

A módosított végponthoz csatlakozó ügyfeleket a végpont újraindítása közben lehet leválasztani vagy elutasítani.

HttpsDefaults konfigurálása

ConfigureHttpsDefaults(Action<HttpsConnectionAdapterOptions>) meghatározza a futtatandó konfigurációt Action minden egyes HTTPS-végponthoz. A ConfigureHttpsDefaults többszöri hívása lecseréli a korábbi Action-eket az utoljára megadott Action-re.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // ...
    });
});

Jegyzet

Ahívása előtt Listen által létrehozott végpontok ConfigureHttpsDefaults nem alkalmazzák az alapértelmezett értékeket.

ListenOptions.UseHttps

Konfigurálja a Kestrel HTTPS használatára.

ListenOptions.UseHttps bővítmények:

UseHttps: Konfigurálja a Kestrel, hogy https-t használjon az alapértelmezett tanúsítvánnyal. Kivételt eredményez, ha nincs alapértelmezett tanúsítvány konfigurálva.
UseHttps(string fileName)
UseHttps(string fileName, string password)
UseHttps(string fileName, string password, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(StoreName storeName, string subject)
UseHttps(StoreName storeName, string subject, bool allowInvalid)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(X509Certificate2 serverCertificate)
UseHttps(X509Certificate2 serverCertificate, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(Action<HttpsConnectionAdapterOptions> configureOptions)

ListenOptions.UseHttps paraméterek:

filename egy tanúsítványfájl elérési útja és fájlneve az alkalmazás tartalomfájljait tartalmazó könyvtárhoz viszonyítva.
password az X.509-tanúsítványadatok eléréséhez szükséges jelszó.
configureOptions egy Action a HttpsConnectionAdapterOptionskonfigurálásához. ListenOptions-t adja vissza.
storeName az a tanúsítványtár, ahonnan betöltik a tanúsítványt.
subject a tanúsítvány tulajdonosának neve.
allowInvalid jelzi, hogy érvénytelen tanúsítványokat kell-e figyelembe venni, például önaláírt tanúsítványokat.
A location a bolt helye, ahonnan a tanúsítvány betöltésre kerül.
serverCertificate az X.509-tanúsítvány.

Éles környezetben a HTTPS-t explicit módon kell konfigurálni. Legalább egy alapértelmezett tanúsítványt kell megadni.

A következőkben ismertetett támogatott konfigurációk:

Nincs konfiguráció
Az alapértelmezett tanúsítvány cseréje a konfigurációból
Az alapértelmezett értékek módosítása a kódban

Nincs konfiguráció

Kestrel figyeli http://localhost:5000 és https://localhost:5001 (ha van alapértelmezett tanúsítvány).

Az alapértelmezett tanúsítvány cseréje a konfigurációból

Az Kestrelszámára elérhető az alapértelmezett HTTPS alkalmazásbeállítások konfigurációs sémája. Konfiguráljon több végpontot, köztük az URL-címeket és a használni kívánt tanúsítványokat egy lemezen lévő fájlból vagy egy tanúsítványtárolóból.

Az alábbi appsettings.json példában:

Állítsa AllowInvalidtrue értékre az érvénytelen tanúsítványok (például önaláírt tanúsítványok) használatának engedélyezéséhez.
Minden olyan HTTPS-végpont, amely nem ad meg tanúsítványt (HttpsDefaultCert a következő példában) a Certificates:Default vagy a fejlesztési tanúsítvány alatt meghatározott tanúsítványra kerül vissza.

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "HttpsInlineCertFile": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertAndKeyFile": {
        "Url": "https://localhost:5002",
        "Certificate": {
          "Path": "<path to .pem/.crt file>",
          "KeyPath": "<path to .key file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertStore": {
        "Url": "https://localhost:5003",
        "Certificate": {
          "Subject": "<subject; required>",
          "Store": "<certificate store; required>",
          "Location": "<location; defaults to CurrentUser>",
          "AllowInvalid": "<true or false; defaults to false>"
        }
      },
      "HttpsDefaultCert": {
        "Url": "https://localhost:5004"
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent a rendszer helyettesítőként használja az egyes tanúsítványok jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. Az éles környezetben lévő tanúsítványjelszavak biztonságos tárolásához lásd az Azure Key Vault konfigurációszolgáltatót. A fejlesztési titkok nem használhatók gyártási vagy tesztelési célokra.

Sémajegyzetek:

A végpontok neve nem érzékeny a kis- és nagybetűkre. A HTTPS és a Https például egyenértékűek.
A Url paraméter minden végponthoz szükséges. A paraméter formátuma megegyezik a legfelső szintű Urls konfigurációs paraméterével, azzal a kivételrel, hogy egyetlen értékre van korlátozva.
Ezek a végpontok a felső szintű Urls konfigurációban definiált végpontokat helyettesítik ahelyett, hogy hozzáadják őket. A kódban Listen keresztül definiált végpontok a konfigurációs szakaszban meghatározott végpontokkal együtt halmozódnak.
A Certificate szakasz nem kötelező. Ha a Certificate szakasz nincs megadva, a rendszer a Certificates:Default definiált alapértelmezett értékeket használja. Ha nem érhetők el alapértelmezett értékek, a rendszer a fejlesztési tanúsítványt használja. Ha nincsenek alapértelmezett értékek, és a fejlesztési tanúsítvány nincs jelen, a kiszolgáló kivételt jelez, és nem indul el.
A Certificate szakasz több tanúsítványforrásttámogat.
Bármilyen számú végpont definiálható konfigurációs, ha nem okoznak portütközéseket.

Tanúsítványforrások

A tanúsítványcsomópontok számos forrásból származó tanúsítványok betöltésére konfigurálhatók:

Path és Password.pfx fájlok betöltéséhez.
Path, KeyPath és Password.pem/.crt és .key fájlok betöltéséhez.
Subject és Store a tanúsítványtárolóból való betöltéshez.

A Certificates:Default tanúsítvány például a következő módon adható meg:

"Default": {
  "Subject": "<subject; required>",
  "Store": "<cert store; required>",
  "Location": "<location; defaults to CurrentUser>",
  "AllowInvalid": "<true or false; defaults to false>"
}

Konfigurációbetöltő

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    var kestrelSection = context.Configuration.GetSection("Kestrel");

    serverOptions.Configure(kestrelSection)
        .Endpoint("HTTPS", listenOptions =>
        {
            // ...
        });
});

KestrelServerOptions.ConfigurationLoader közvetlenül elérhető a meglévő rakodón való iterálás folytatásához, például a WebApplicationBuilder.WebHostáltal biztosított.

Az egyes végpontok konfigurációs szakasza a Endpoint metódus beállításai között érhető el, hogy az egyéni beállítások olvashatók legyenek.
Előfordulhat, hogy több konfiguráció is betöltődik, ha ismét meghívja Configure(IConfiguration) egy másik szakaszsal. Csak az utolsó konfigurációt használja a rendszer, kivéve, ha a Load kifejezetten meg van hívva a korábbi példányokra. A metacsomag nem hívja meg Load, hogy az alapértelmezett konfigurációs szakasz lecserélhető legyen.
KestrelConfigurationLoader az API Listen családját KestrelServerOptionsEndpoint overload-ként tükrözi, így a kód- és konfigurációs végpontok egy helyen konfigurálhatók. Ezek a túlterhelések nem használnak neveket, és csak a konfiguráció alapértelmezett beállításait használják.

Az alapértelmezett értékek módosítása a kódban

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // ...
    });

    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // ...
    });
});

Végpontok konfigurálása kiszolgálónév-jelzéssel

Az SNI kétféleképpen konfigurálható:

Hozzon létre egy végpontot a kódban, és válasszon ki egy tanúsítványt a gazdagép nevét használva a ServerCertificateSelector visszahívással.
A hostnevek és a HTTPS-beállítások közötti leképezést konfigurálja a Konfigurációsrészben. A JSON például a appsettings.json fájlban.

SNI `ServerCertificateSelector`

Kestrel támogatja az SNI-t a ServerCertificateSelector visszahívási funkción keresztül. A visszahívást kapcsolatonként egyszer hívjuk meg, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthassa a megfelelő tanúsítványt:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var subExampleCert = CertificateLoader.LoadFromStoreCert(
                "sub.example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var certs = new Dictionary<string, X509Certificate2>(
                StringComparer.OrdinalIgnoreCase)
            {
                ["localhost"] = localhostCert,
                ["example.com"] = exampleCert,
                ["sub.example.com"] = subExampleCert
            };

            httpsOptions.ServerCertificateSelector = (connectionContext, name) =>
            {
                if (name is not null && certs.TryGetValue(name, out var cert))
                {
                    return cert;
                }

                return exampleCert;
            };
        });
    });
});

SNI `ServerOptionsSelectionCallback`

Kestrel támogatja a további dinamikus TLS-konfigurációt a ServerOptionsSelectionCallback visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt és TLS-konfigurációt. Ez a visszahívás nem használja az alapértelmezett tanúsítványokat és a ConfigureHttpsDefaults-t.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps((stream, clientHelloInfo, state, cancellationToken) =>
            {
                if (string.Equals(clientHelloInfo.ServerName, "localhost",
                    StringComparison.OrdinalIgnoreCase))
                {
                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = localhostCert,
                            // Different TLS requirements for this host
                            ClientCertificateRequired = true
                        });
                }

                return new ValueTask<SslServerAuthenticationOptions>(
                    new SslServerAuthenticationOptions
                    {
                        ServerCertificate = exampleCert
                    });
            }, state: null!);
        });
    });
});

SNI `TlsHandshakeCallbackOptions`

Kestrel támogatja a további dinamikus TLS-konfigurációt a TlsHandshakeCallbackOptions.OnConnection visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt, a TLS-konfigurációt és más kiszolgálóbeállításokat. Ez a visszahívás nem használja az alapértelmezett tanúsítványokat és a ConfigureHttpsDefaults-t.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps(new TlsHandshakeCallbackOptions
            {
                OnConnection = context =>
                {
                    if (string.Equals(context.ClientHelloInfo.ServerName, "localhost",
                        StringComparison.OrdinalIgnoreCase))
                    {
                        // Different TLS requirements for this host
                        context.AllowDelayedClientCertificateNegotation = true;

                        return new ValueTask<SslServerAuthenticationOptions>(
                            new SslServerAuthenticationOptions
                            {
                                ServerCertificate = localhostCert
                            });
                    }

                    return new ValueTask<SslServerAuthenticationOptions>(
                        new SslServerAuthenticationOptions
                        {
                            ServerCertificate = exampleCert
                        });
                }
            });
        });
    });
});

SNI a konfigurációban

A következő konfiguráció hozzáad egy MySniEndpoint nevű végpontot, amely az SNI használatával választja ki a HTTPS-beállításokat a gazdagép neve alapján:

{
  "Kestrel": {
    "Endpoints": {
      "MySniEndpoint": {
        "Url": "https://*",
        "SslProtocols": ["Tls11", "Tls12"],
        "Sni": {
          "a.example.org": {
            "Protocols": "Http1AndHttp2",
            "SslProtocols": ["Tls11", "Tls12", "Tls13"],
            "Certificate": {
              "Subject": "<subject; required>",
              "Store": "<certificate store; required>",
            },
            "ClientCertificateMode" : "NoCertificate"
          },
          "*.example.org": {
            "Certificate": {
              "Path": "<path to .pfx file>",
              "Password": "$CREDENTIAL_PLACEHOLDER$"
            }
          },
          "*": {
            // At least one subproperty needs to exist per SNI section or it
            // cannot be discovered via IConfiguration
            "Protocols": "Http1",
          }
        }
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent helyettesítőként használják minden egyes tanúsítvány jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásához lásd az Azure Key Vault konfigurációs szolgáltatóját a hivatkozás alatt. A fejlesztési titkokat nem szabad éles vagy tesztelési célokra használni.

AZ SNI által felülírható HTTPS-beállítások:

Certificate konfigurálja a tanúsítványforrás.
Protocols konfigurálja az engedélyezett HTTP-protokollokat.
SslProtocols konfigurálja az engedélyezett SSL-protokollokat.
ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

A gazdagép neve támogatja a helyettesítő karakterek egyeztetését:

Pontos egyezés. Például a.example.org egyezik a.example.org.
Helyettesítő karakter előtag. Ha több helyettesítő karakteres egyezés van, akkor a leghosszabb mintát választják. Például *.example.org egyezik b.example.org-gyel és c.example.org-vel.
Teljes helyettesítő karakter. * megfelel mindennek másnak, beleértve azokat az ügyfeleket is, amelyek nem használnak SNI-t, és nem küldenek hosznevet.

SNI-követelmények

Minden webhelynek ugyanazon a Kestrel példányon kell futnia. Kestrel nem támogatja egy IP-cím és port megosztását több példány között fordított proxy nélkül.

SSL-/TLS-protokollok

Az SSL-protokollok olyan protokollok, amelyek két társ, hagyományosan egy ügyfél és egy kiszolgáló közötti forgalom titkosítására és visszafejtésére szolgálnak.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.SslProtocols = SslProtocols.Tls13;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "SslProtocols": ["Tls12", "Tls13"],
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyettesítője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásáról lásd a Azure Key Vault konfigurációs szolgáltatót. A fejlesztési titkok nem használhatók éles vagy tesztelési célokra.

Ügyféltanúsítványok

ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "ClientCertificateMode": "AllowCertificate",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásához lásd a Azure Key Vault konfigurációs szolgáltató.

Az alapértelmezett érték ClientCertificateMode.NoCertificate, ahol Kestrel nem kér vagy igényel tanúsítványt az ügyféltől.

További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

Kapcsolatnaplózás

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseConnectionLogging();
    });
});

Kapcsolódás TCP-hálózati foglalathoz

A Listen metódus egy TCP-szoftvercsatornához kapcsolódik, és egy beállítási lambda engedélyezi az X.509-tanúsítványkonfigurációt:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
    });
});

A példa egy végpont számára konfigurálja a HTTPS-t ListenOptions-val. Ugyanezzel az API-val konfigurálhat más Kestrel beállításokat adott végpontokhoz.

Windows rendszeren az önaláírt tanúsítványok a New-SelfSignedCertificate PowerShell-parancsmaghasználatával hozhatók létre. Nem támogatott példa: UpdateIISExpressSSLForChrome.ps1.

MacOS, Linux és Windows rendszeren a tanúsítványok OpenSSLhasználatával hozhatók létre.

Kötés Unix-szoftvercsatornához

Használjon egy Unix socketet ListenUnixSocket az Nginx jobb teljesítménye érdekében, ahogy azt ez a példa mutatja:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ListenUnixSocket("/tmp/kestrel-test.sock");
});

Az Nginx konfigurációs fájlban állítsa a server>location>proxy_pass bejegyzést http://unix:/tmp/{KESTREL SOCKET}:/;értékre. {KESTREL SOCKET} a ListenUnixSocket számára biztosított foglalat neve (például az előző példában kestrel-test.sock).
Győződjön meg róla, hogy a socket írható az Nginx által (például chmod go+w /tmp/kestrel-test.sock).

Port 0

Ha a portszám 0 van megadva, Kestrel dinamikusan kapcsolódik egy elérhető porthoz. Az alábbi példa bemutatja, hogyan határozható meg, hogy futásidőben melyik porthoz kötődik Kestrel.

app.Run(async (context) =>
{
    var serverAddressFeature = context.Features.Get<IServerAddressesFeature>();

    if (serverAddressFeature is not null)
    {
        var listenAddresses = string.Join(", ", serverAddressFeature.Addresses);

        // ...
    }
});

Korlátozások

A végpontok konfigurálása a következő módszerekkel:

UseUrls
--urls parancssori argumentum
urls gazdagép konfigurációs kulcs
ASPNETCORE_URLS környezeti változó

Ezek a módszerek a Kestrelkívüli kiszolgálókon való kódmunkához hasznosak. Vegye figyelembe azonban a következő korlátozásokat:

A HTTPS csak akkor használható ezekkel a módszerekkel, ha a HTTPS-végpont konfigurációjában egy alapértelmezett tanúsítvány van megadva (például KestrelServerOptions konfigurációval vagy konfigurációs fájllal, ahogyan a cikk korábbi részében látható).
A Listen és a UseUrls megközelítés egyidejű használata esetén a Listen végpontok felülbírálják a UseUrls végpontokat.

IIS-végpont konfigurálása

Az IIS használatakor az IIS felülbírálási kötéseinek URL-kötéseit Listen vagy UseUrlsállítja be. További információ: ASP.NET Core Module.

FigyelésiBeállítások.Protokollok

`HttpProtocols` számérték	Engedélyezett kapcsolati protokoll
`Http1`	Csak HTTP/1.1. TLS-sel vagy anélkül is használható.
`Http2`	Kizárólag HTTP/2 támogatott. TLS nélkül csak akkor használható, ha az ügyfél támogatja a Korábbi tudás mód.
`Http1AndHttp2`	HTTP/1.1 és HTTP/2. A HTTP/2 megköveteli, hogy az ügyfél a HTTP/2-t válassza a TLS Application-Layer Protokollalku (ALPN) kézfogás során; ellenkező esetben a kapcsolat alapértelmezés szerint a HTTP/1.1-et használja.

A végpontok alapértelmezett ListenOptions.Protocols értéke HttpProtocols.Http1AndHttp2.

TLS-korlátozások HTTP/2-hez:

TLS 1.2-es vagy újabb verzió
Az újratárgyalás le van tiltva
Tömörítés letiltva
Rövid élettartamú kulcscsere minimális méretei:
- Elliptikus görbe Diffie-Hellman (ECDHE) [RFC4492]: legalább 224 bit
- Véges mező Diffie-Hellman (DHE) [TLS12]: legalább 2048 bit
A titkosítási csomag nem tiltott.

Alapértelmezés szerint támogatott a TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 [TLS-ECDHE] a P-256 elliptikus görbével [FIPS186].

Az alábbi példa HTTP/1.1 és HTTP/2 kapcsolatokat engedélyez a 8000-s porton. A kapcsolatokat a TLS egy megadott tanúsítvánnyal védi:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
    });
});

Linuxon CipherSuitesPolicy használható a TLS-kézfogások kapcsolatonkénti szűrésére:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.OnAuthenticate = (context, sslOptions) =>
        {
            sslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(
                new[]
                {
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                    // ...
                });
        };
    });
});

Kapcsolat köztes szoftvere

Az egyéni kapcsolat-közvetítő szükség esetén kapcsolatonként szűrheti a TLS-handshake-eket bizonyos titkosítási módok alapján.

Az alábbi példa NotSupportedException-t dob bármely titkosítási algoritmus esetén, amelyet az alkalmazás nem támogat. Másik lehetőségként definiálhatja és összehasonlíthatja a ITlsHandshakeFeature.CipherAlgorithm az elfogadható titkosítási csomagok listájával.

A rendszer nem használ titkosítást CipherAlgorithmType.Null titkosítási algoritmussal.

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");

        listenOptions.Use((context, next) =>
        {
            var tlsFeature = context.Features.Get<ITlsHandshakeFeature>()!;

            if (tlsFeature.CipherAlgorithm == CipherAlgorithmType.Null)
            {
                throw new NotSupportedException(
                    $"Prohibited cipher: {tlsFeature.CipherAlgorithm}");
            }

            return next();
        });
    });
});

A HTTP-protokoll beállítása konfigurációból

{
  "Kestrel": {
    "EndpointDefaults": {
      "Protocols": "Http1"
    }
  }
}

Az alábbi appsettings.json példa a HTTP/1.1 kapcsolati protokollt hozza létre egy adott végponthoz:

{
  "Kestrel": {
    "Endpoints": {
      "HttpsDefaultCert": {
        "Url": "https://localhost:5001",
        "Protocols": "Http1"
      }
    }
  }
}

A konfiguráció által beállított kód felülbírálási értékekben megadott protokollok.

URL-előtagok

Csak a HTTP URL-előtagok érvényesek. Kestrel nem támogatja a HTTPS-t az URL-kötések UseUrlshasználatával történő konfigurálásakor.

IPv4-cím portszámmal
```
http://65.55.39.10:80/
```
0.0.0.0 egy speciális eset, amely az összes IPv4-címhez kötődik.
IPv6-cím portszámmal
```
http://[0:0:0:0:0:ffff:4137:270a]:80/
```
[::] az IPv4 0.0.0.0IPv6-megfelelője.
Kiszolgálónév portszámmal
```
http://contoso.com:80/
http://*:80/
```
A hosztnevek, *és +, nem különlegesek. Az érvényes IP-címként nem felismert vagy localhost minden IPv4- és IPv6-IP-címhez kapcsolódik. Ha különböző gazdagépneveket szeretne más ASP.NET Core-alkalmazásokhoz kötni ugyanazon a porton, használjon HTTP.sys vagy fordított proxykiszolgálót. A fordított proxykiszolgálók például az IIS, az Nginx vagy az Apache.

Figyelmeztetés

A fordított proxykonfigurációban való üzemeltetéshez gazdagépszűrésiszükséges.
Gazdagép localhost neve portszámmal vagy visszacsatolási IP-cím portszámmal
```
http://localhost:5000/
http://127.0.0.1:5000/
http://[::1]:5000/
```
Ha localhost van megadva, Kestrel IPv4- és IPv6-visszacsatolási felületekhez is megpróbál csatlakozni. Ha a kért portot egy másik szolgáltatás használja bármelyik visszacsatolási felületen, Kestrel nem indul el. Ha bármelyik visszacsatolási felület más okból nem érhető el (leggyakrabban azért, mert az IPv6 nem támogatott), Kestrel figyelmeztetést naplóz.

Alapértelmezés szerint ASP.NET Core a következőhöz kötődik:

http://localhost:5000
https://localhost:5001 (helyi fejlesztési tanúsítvány esetén)

Adja meg az URL-címeket a következővel:

ASPNETCORE_URLS környezeti változó.
--urls parancssori argumentum.
urls gazdagép konfigurációs kulcs
UseUrls bővítménymetódus.

További információ ezekről a módszerekről: kiszolgálói URL-címek és konfiguráció felülbírálása.

Létrejön egy fejlesztési tanúsítvány:

Amikor a .NET SDK telepítve van.
A dev-certs eszköz egy tanúsítvány létrehozásához használható.

Egyes böngészők explicit engedélyt igényelnek a helyi fejlesztési tanúsítvány megbízhatóságához.

A projektsablonok alapértelmezés szerint HTTPS-alapú futtatásra konfigurálják az alkalmazásokat, és tartalmazzák HTTPS-átirányítást és a HSTS-támogatást.

Hívja meg a Listen vagy ListenUnixSocket metódusokat, a KestrelServerOptions URL-előtagjainak és portjainak konfigurálásához Kestrelszámára.

KestrelServerOptions konfiguráció:

Konfigurálja az alapszintű végpontbeállításokat

ConfigureEndpointDefaults(Action<ListenOptions>) egy konfigurációs Action határoz meg, amely minden megadott végponthoz futtatható. A ConfigureEndpointDefaults többszöri hívása lecseréli az összes korábbi Action-et az utoljára megadott Action-vel.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // Configure endpoint defaults
    });
});

Jegyzet

A Listenhívásával létrehozott végpontok nem fogják alkalmazni az alapértelmezéseket, ha a előtt hívják a ConfigureEndpointDefaults-at.

Konfigurálás(IConfiguration)

Lehetővé teszi, hogy Kestrel betöltse a végpontokat IConfiguration-ből. A konfigurációt a Kestrelkonfigurációs szakaszára kell korlátozni.

A Configure(IConfiguration, bool) túlterhelés a végpontok újratöltésének engedélyezésére használható, amikor a konfigurációs forrás megváltozik.

IHostBuilder.ConfigureWebHostDefaults alapértelmezés szerint meghívja Configure(context.Configuration.GetSection("Kestrel"), reloadOnChange: true)Kestrel konfiguráció betöltéséhez és az újratöltés engedélyezéséhez.

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "Https": {
        "Url": "https://localhost:5001"
      }
    }
  }
}

Ha a konfiguráció újratöltése engedélyezve van, és a rendszer módosítást jelez, a következő lépéseket kell végrehajtania:

Az új konfiguráció a régihez hasonlítható, a konfigurációmódosítás nélküli végpontok nem módosulnak.
Az eltávolított vagy módosított végpontok 5 másodpercet kapnak a feldolgozási kérelmek befejezéséhez és leállításához.
Új vagy módosított végpontok indulnak el.

A módosított végponthoz csatlakozó ügyfeleket a végpont újraindítása közben lehet leválasztani vagy elutasítani.

HttpsAlapértelmezésekKonfigurálása

ConfigureHttpsDefaults(Action<HttpsConnectionAdapterOptions>) meghatároz egy Action konfigurációt, amelyet minden egyes HTTPS-végponthoz futtatni kell. A ConfigureHttpsDefaults többszöri hívása lecseréli a korábbi Action-eket az utoljára megadott Action-re.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        // certificate is an X509Certificate2
        listenOptions.ServerCertificate = certificate;
    });
});

Jegyzet

Ahívása előtt Listen által létrehozott végpontok ConfigureHttpsDefaults nem alkalmazzák az alapértelmezett értékeket.

ListenOptions.UseHttps

Konfigurálja a Kestrel HTTPS használatára.

ListenOptions.UseHttps bővítmények:

UseHttps: Konfigurálja a Kestrel, hogy https-t használjon az alapértelmezett tanúsítvánnyal. Kivételt eredményez, ha nincs alapértelmezett tanúsítvány konfigurálva.
UseHttps(string fileName)
UseHttps(string fileName, string password)
UseHttps(string fileName, string password, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(StoreName storeName, string subject)
UseHttps(StoreName storeName, string subject, bool allowInvalid)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location)
UseHttps(StoreName storeName, string subject, bool allowInvalid, StoreLocation location, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(X509Certificate2 serverCertificate)
UseHttps(X509Certificate2 serverCertificate, Action<HttpsConnectionAdapterOptions> configureOptions)
UseHttps(Action<HttpsConnectionAdapterOptions> configureOptions)

ListenOptions.UseHttps paraméterek:

filename egy tanúsítványfájl elérési útja és fájlneve az alkalmazás tartalomfájljait tartalmazó könyvtárhoz viszonyítva.
password az X.509-tanúsítványadatok eléréséhez szükséges jelszó.
configureOptions egy Action a HttpsConnectionAdapterOptionskonfigurálásához. A ListenOptions-t adja vissza.
storeName a tanúsítványtár, amelyből be kell tölteni a tanúsítványt.
subject a tanúsítvány tulajdonosának neve.
allowInvalid jelzi, hogy érvénytelen tanúsítványokat kell-e figyelembe venni, például önaláírt tanúsítványokat.
A location a bolt helye, ahonnan a tanúsítványt be kell tölteni.
serverCertificate az X.509-tanúsítvány.

Éles környezetben a HTTPS-t explicit módon kell konfigurálni. Legalább egy alapértelmezett tanúsítványt kell megadni.

A következőkben ismertetett támogatott konfigurációk:

Nincs konfiguráció
Az alapértelmezett tanúsítvány cseréje a konfigurációból
Az alapértelmezett értékek módosítása a kódban

Nincs konfiguráció

Kestrel figyeli http://localhost:5000 és https://localhost:5001 (ha van alapértelmezett tanúsítvány).

Az alapértelmezett tanúsítvány cseréje a konfigurációból

Az alapértelmezett HTTPS-alkalmazásbeállítások konfigurációs sémája elérhető a Kestrelszámára. Konfiguráljon több végpontot, köztük az URL-címeket és a használni kívánt tanúsítványokat egy lemezen lévő fájlból vagy egy tanúsítványtárolóból.

Az alábbi appsettings.json példában:

Állítsa AllowInvalid-ról true-re, hogy engedélyezze az érvénytelen tanúsítványok (például önaláírt tanúsítványok) használatát.
Minden olyan HTTPS-végpont, amely nem ad meg tanúsítványt (HttpsDefaultCert a következő példában) a Certificates:Default vagy a fejlesztési tanúsítvány alatt meghatározott tanúsítványra kerül vissza.

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "HttpsInlineCertFile": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertAndKeyFile": {
        "Url": "https://localhost:5002",
        "Certificate": {
          "Path": "<path to .pem/.crt file>",
          "KeyPath": "<path to .key file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      },
      "HttpsInlineCertStore": {
        "Url": "https://localhost:5003",
        "Certificate": {
          "Subject": "<subject; required>",
          "Store": "<certificate store; required>",
          "Location": "<location; defaults to CurrentUser>",
          "AllowInvalid": "<true or false; defaults to false>"
        }
      },
      "HttpsDefaultCert": {
        "Url": "https://localhost:5004"
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent helyettesítőként használják az egyes tanúsítványok jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásához tekintse meg az Azure Key Vault konfigurációszolgáltatóját . A fejlesztési titkok nem használhatók éles környezetben vagy tesztelésre.

Sémajegyzetek:

A végpontok nevei nem érzékenyek a kis- és nagybetűkre . A HTTPS és a Https például egyenértékűek.
A Url paraméter minden végponthoz szükséges. A paraméter formátuma megegyezik a legfelső szintű Urls konfigurációs paraméterével, azzal a kivételrel, hogy egyetlen értékre van korlátozva.
Ezek a végpontok a felső szintű Urls konfigurációban definiált végpontokat helyettesítik ahelyett, hogy hozzáadják őket. A kódban Listen keresztül definiált végpontok a konfigurációs szakaszban meghatározott végpontokkal együtt halmozódnak.
A Certificate szakasz nem kötelező. Ha a Certificate szakasz nincs megadva, a rendszer a Certificates:Default definiált alapértelmezett értékeket használja. Ha nem érhetők el alapértelmezett értékek, a rendszer a fejlesztési tanúsítványt használja. Ha nincsenek alapértelmezett értékek, és a fejlesztési tanúsítvány nincs jelen, a kiszolgáló kivételt jelez, és nem indul el.
A Certificate szakasz több tanúsítványforrásttámogat.
Bármilyen számú végpont definiálható konfigurációs, ha nem okoznak portütközéseket.

Tanúsítványforrások

A tanúsítványcsomópontok számos forrásból származó tanúsítványok betöltésére konfigurálhatók:

A .pfx fájlok betöltéséhez Path és Password.
Path, KeyPath és Password.pem/.crt és .key fájlok betöltéséhez.
Subject és Store a tanúsítványtárolóból való betöltéshez.

A Certificates:Default tanúsítvány például a következő módon adható meg:

"Default": {
  "Subject": "<subject; required>",
  "Store": "<cert store; required>",
  "Location": "<location; defaults to CurrentUser>",
  "AllowInvalid": "<true or false; defaults to false>"
}

Konfigurációbetöltő

options.Configure(context.Configuration.GetSection("{SECTION}")) egy .Endpoint(string name, listenOptions => { }) metódussal rendelkező KestrelConfigurationLoader ad vissza, amely egy konfigurált végpont beállításainak kiegészítésére használható:

webBuilder.UseKestrel((context, serverOptions) =>
{
    serverOptions.Configure(context.Configuration.GetSection("Kestrel"))
        .Endpoint("HTTPS", listenOptions =>
        {
            listenOptions.HttpsOptions.SslProtocols = SslProtocols.Tls12;
        });
});

KestrelServerOptions.ConfigurationLoader közvetlenül elérhető a meglévő rakodón való iterálás folytatásához, például a CreateDefaultBuilderáltal biztosított.

Az egyes végpontok konfigurációs szakasza a Endpoint metódus beállításai között érhető el, hogy az egyéni beállítások olvashatók legyenek.
Előfordulhat, hogy több konfiguráció is betöltődik, ha ismét meghívja options.Configure(context.Configuration.GetSection("{SECTION}")) egy másik szakaszsal. Csak az utolsó konfigurációt használja a rendszer, kivéve, ha a korábbi példányokhoz kifejezetten Load-t hívják meg. A metacsomag nem hívja meg Load, hogy az alapértelmezett konfigurációs szakasz lecserélhető legyen.
KestrelConfigurationLoader az API-k Listen családját KestrelServerOptionsEndpoint túlterhelésként tükrözi, így a kód- és konfigurációvégpontok ugyanazon a helyen konfigurálhatók. Ezek a túlterhelések nem használnak neveket, és csak a konfiguráció alapértelmezett beállításait használják.

Az alapértelmezett értékek módosítása a kódban

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        // Configure endpoint defaults
    });

    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.SslProtocols = SslProtocols.Tls12;
    });
});

Végpontok konfigurálása kiszolgálónév-jelzéssel

Az SNI kétféleképpen konfigurálható:

Hozzon létre egy végpontot a kódban, és válasszon ki egy tanúsítványt a gazdagép nevével a ServerCertificateSelector visszahívással.
A gazdagépnevek és a HTTPS-beállítások közötti leképezés konfigurálása Konfigurációs. A JSON például a appsettings.json fájlban.

SNI `ServerCertificateSelector`

Kestrel támogatja az SNI-t a ServerCertificateSelector hívásán keresztül. A visszahívást kapcsolatonként egyszer hívjuk meg, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthassa a megfelelő tanúsítványt. A projekt Program.cs fájljának ConfigureWebHostDefaults metódushívásában a következő visszahívási kód használható:

// using System.Security.Cryptography.X509Certificates;
// using Microsoft.AspNetCore.Server.Kestrel.Https;

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var subExampleCert = CertificateLoader.LoadFromStoreCert(
                "sub.example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var certs = new Dictionary<string, X509Certificate2>(StringComparer.OrdinalIgnoreCase)
            {
                { "localhost", localhostCert },
                { "example.com", exampleCert },
                { "sub.example.com", subExampleCert },
            };            

            httpsOptions.ServerCertificateSelector = (connectionContext, name) =>
            {
                if (name != null && certs.TryGetValue(name, out var cert))
                {
                    return cert;
                }

                return exampleCert;
            };
        });
    });
});

SNI `ServerOptionsSelectionCallback`

Kestrel támogatja a további dinamikus TLS-konfigurációt a ServerOptionsSelectionCallback visszahíváson keresztül. A rendszer kapcsolatonként egyszer hívja meg a visszahívást, hogy az alkalmazás megvizsgálhassa a gazdagép nevét, és kiválaszthatja a megfelelő tanúsítványt és TLS-konfigurációt. Ez a visszahívás nem használja az alapértelmezett tanúsítványokat és a ConfigureHttpsDefaults-t.

// using System.Security.Cryptography.X509Certificates;
// using Microsoft.AspNetCore.Server.Kestrel.Https;

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenAnyIP(5005, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            var localhostCert = CertificateLoader.LoadFromStoreCert(
                "localhost", "My", StoreLocation.CurrentUser,
                allowInvalid: true);
            var exampleCert = CertificateLoader.LoadFromStoreCert(
                "example.com", "My", StoreLocation.CurrentUser,
                allowInvalid: true);

            listenOptions.UseHttps((stream, clientHelloInfo, state, cancellationToken) =>
            {
                if (string.Equals(clientHelloInfo.ServerName, "localhost", StringComparison.OrdinalIgnoreCase))
                {
                    return new ValueTask<SslServerAuthenticationOptions>(new SslServerAuthenticationOptions
                    {
                        ServerCertificate = localhostCert,
                        // Different TLS requirements for this host
                        ClientCertificateRequired = true,
                    });
                }

                return new ValueTask<SslServerAuthenticationOptions>(new SslServerAuthenticationOptions
                {
                    ServerCertificate = exampleCert,
                });
            }, state: null);
        });
    });
});

SNI konfigurációban

A következő konfiguráció hozzáad egy MySniEndpoint nevű végpontot, amely az SNI használatával választja ki a HTTPS-beállításokat a gazdagép neve alapján:

{
  "Kestrel": {
    "Endpoints": {
      "MySniEndpoint": {
        "Url": "https://*",
        "SslProtocols": ["Tls11", "Tls12"],
        "Sni": {
          "a.example.org": {
            "Protocols": "Http1AndHttp2",
            "SslProtocols": ["Tls11", "Tls12", "Tls13"],
            "Certificate": {
              "Subject": "<subject; required>",
              "Store": "<certificate store; required>",
            },
            "ClientCertificateMode" : "NoCertificate"
          },
          "*.example.org": {
            "Certificate": {
              "Path": "<path to .pfx file>",
              "Password": "$CREDENTIAL_PLACEHOLDER$"
            }
          },
          "*": {
            // At least one subproperty needs to exist per SNI section or it
            // cannot be discovered via IConfiguration
            "Protocols": "Http1",
          }
        }
      }
    },
    "Certificates": {
      "Default": {
        "Path": "<path to .pfx file>",
        "Password": "$CREDENTIAL_PLACEHOLDER$"
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszavak egyszerű szövegben vannak tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ tokent helykitöltőként használják az egyes tanúsítványok jelszavához. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavaknak éles környezetben való biztonságos tárolásához tekintse meg az Azure Key Vault konfigurációszolgáltatóját a alatt. A fejlesztési titkok nem használhatók éles vagy tesztelési célokra.

AZ SNI által felülírható HTTPS-beállítások:

Certificate konfigurálja a tanúsítványforrás.
Protocols konfigurálja az engedélyezett HTTP-protokollokat.
SslProtocols konfigurálja az engedélyezett SSL-protokollokat.
ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

A gazdagép neve támogatja a helyettesítő karakterek egyeztetését:

Pontos egyezés. Például a.example.org egyezik a.example.org.
Helyettesítő karakter előtag Ha egy helyettesítő karakter alapján több megegyezés van, akkor a leghosszabb minta kerül kiválasztásra. *.example.org egyezik b.example.org és c.example.org-vel.
Teljes helyettesítő karakter. * megegyezik minden mással, beleértve azokat az ügyfeleket is, amelyek nem használnak SNI-t, és nem küldenek hosztnevet.

SNI-követelmények

A cél-keretrendszer netcoreapp2.1 vagy újabb verzióján fut. A visszahívás net461 vagy későbbi időpontban történik, de a name mindig null. A name akkor is null, ha az ügyfél nem adja meg a gazdagépnév paramétert a TLS-kézfogás során.
Minden webhely ugyanazon a Kestrel példányon fut. Kestrel nem támogatja az IP-cím és a port megosztását több példány esetén anélkül, hogy fordított proxy lenne használatban.

SSL-/TLS-protokollok

Az SSL-protokollok olyan protokollok, amelyek két társ, hagyományosan egy ügyfél és egy kiszolgáló közötti forgalom titkosítására és visszafejtésére szolgálnak.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.SslProtocols = SslProtocols.Tls13;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "SslProtocols": ["Tls12", "Tls13"],
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyettesítője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetekben való biztonságos tárolásához lásd az Azure Key Vault konfigurációs szolgáltatóját . A fejlesztési titkok nem használhatók éles vagy tesztelési célokra.

Ügyféltanúsítványok

ClientCertificateMode konfigurálja az ügyféltanúsítvány-követelményeket.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
    });
});

{
  "Kestrel": {
    "Endpoints": {
      "MyHttpsEndpoint": {
        "Url": "https://localhost:5001",
        "ClientCertificateMode": "AllowCertificate",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "$CREDENTIAL_PLACEHOLDER$"
        }
      }
    }
  }
}

Figyelmeztetés

Az előző példában a tanúsítványjelszó egyszerű szövegben lesz tárolva appsettings.json. A $CREDENTIAL_PLACEHOLDER$ token a tanúsítvány jelszavának helyőrzője. A tanúsítványjelszavak biztonságos tárolásáról a fejlesztői környezetekben Titkos kódok védelme a fejlesztésicímű témakörben olvashat. A tanúsítványjelszavak éles környezetben való biztonságos tárolásával kapcsolatos részletekért tekintse meg az Azure Key Vault konfigurációs szolgáltatót . A fejlesztési titkok nem használhatók éles vagy tesztkörnyezetben.

Az alapértelmezett érték ClientCertificateMode.NoCertificate, ahol Kestrel nem kér vagy igényel tanúsítványt az ügyféltől.

További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

Kapcsolatnaplózás

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseConnectionLogging();
    });
});

TCP foglalathoz kötés

A Listen metódus egy TCP-szoftvercsatornához kapcsolódik, és egy beállítási lambda engedélyezi az X.509-tanúsítványkonfigurációt:

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

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.ConfigureKestrel(serverOptions =>
            {
                serverOptions.Listen(IPAddress.Loopback, 5000);
                serverOptions.Listen(IPAddress.Loopback, 5001, 
                    listenOptions =>
                    {
                        listenOptions.UseHttps("testCert.pfx", 
                            "testPassword");
                    });
            })
            .UseStartup<Startup>();
        });

A példa a HTTPS-t konfigurálja a ListenOptionsvégponthoz. Ugyanezzel az API-val konfigurálhat más Kestrel beállításokat adott végpontokhoz.

Windows rendszeren az önaláírt tanúsítványok a New-SelfSignedCertificate PowerShell-parancsmaghasználatával hozhatók létre. Nem támogatott példáért lásd: UpdateIISExpressSSLForChrome.ps1.

MacOS, Linux és Windows rendszeren a tanúsítványok OpenSSLhasználatával hozhatók létre.

Kötés Unix-szoftvercsatornához

Használjon egy Unix socketet ListenUnixSocket az Nginx teljesítményének javítása érdekében, ahogy az ebben a példában látható:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenUnixSocket("/tmp/kestrel-test.sock");
    serverOptions.ListenUnixSocket("/tmp/kestrel-test.sock", 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testpassword");
        });
})

Az Nginx konfigurációs fájlban állítsa a server>location>proxy_pass bejegyzést http://unix:/tmp/{KESTREL SOCKET}:/;értékre. {KESTREL SOCKET} a ListenUnixSocket számára biztosított foglalat neve (például az előző példában kestrel-test.sock).
Győződjön meg arról, hogy a csatlakozó írható az Nginx által (például chmod go+w /tmp/kestrel-test.sock).

Port 0

Ha a portszám 0 van megadva, Kestrel dinamikusan kapcsolódik egy elérhető porthoz. Az alábbi példa bemutatja, hogyan határozható meg, hogy melyik porthoz van kötve a Kestrel futásidőben.

public void Configure(IApplicationBuilder app)
{
    var serverAddressesFeature =
        app.ServerFeatures.Get<IServerAddressesFeature>();

    app.UseStaticFiles();

    app.Run(async (context) =>
    {
        context.Response.ContentType = "text/html";
        await context.Response
            .WriteAsync("<!DOCTYPE html><html lang=\"en\"><head>" +
                "<title></title></head><body><p>Hosted by Kestrel</p>");

        if (serverAddressesFeature != null)
        {
            await context.Response
                .WriteAsync("<p>Listening on the following addresses: " +
                    string.Join(", ", serverAddressesFeature.Addresses) +
                    "</p>");
        }

        await context.Response.WriteAsync("<p>Request URL: " +
            $"{context.Request.GetDisplayUrl()}<p>");
    });
}

Az alkalmazás futtatásakor a konzolablak kimenete azt a dinamikus portot jelzi, ahol az alkalmazás elérhető:

Listening on the following addresses: http://127.0.0.1:48508

Korlátozások

A végpontok konfigurálása a következő módszerekkel:

UseUrls
--urls parancssori argumentum
urls gazdagép konfigurációs kulcs
ASPNETCORE_URLS környezeti változó

Ezek a módszerek a Kestrelkívüli kiszolgálókon való kódmunkához hasznosak. Vegye figyelembe azonban a következő korlátozásokat:

A HTTPS csak akkor használható ezekkel a módszerekkel, ha a HTTPS-végpont konfigurációjában egy alapértelmezett tanúsítvány van megadva (például KestrelServerOptions konfigurációval vagy konfigurációs fájllal, ahogyan a cikk korábbi részében látható).
A Listen és a UseUrls megközelítés egyidejű használata esetén a Listen végpontok felülbírálják a UseUrls végpontokat.

IIS-végpont konfigurálása

Az IIS használatakor az IIS felülbírálási kötéseinek URL-kötéseit Listen vagy UseUrlsállítja be. További információ: ASP.NET Core Module.

ListenOptions.Protocols

`HttpProtocols` számérték	Engedélyezett kapcsolati protokoll
`Http1`	Csak HTTP/1.1. TLS-sel vagy anélkül is használható.
`Http2`	CSAK HTTP/2. TLS nélkül csak akkor használható, ha az ügyfél támogatja a Korábbi tudás mód.
`Http1AndHttp2`	HTTP/1.1 és HTTP/2. A HTTP/2 protokoll megköveteli, hogy az ügyfél a HTTP/2-t válassza a TLS Application-Layer Protokollalku (ALPN) Kézfogásban; ellenkező esetben a kapcsolat alapértelmezés szerint HTTP/1.1.

A végpontok alapértelmezett ListenOptions.Protocols értéke HttpProtocols.Http1AndHttp2.

TLS-korlátozások HTTP/2-hez:

TLS 1.2-es vagy újabb verzió
Az újratárgyalás le van tiltva
Tömörítés letiltva
Rövid élettartamú kulcscsere minimális méretei:
- Elliptikus görbe Diffie-Hellman (ECDHE) [RFC4492]: legalább 224 bit
- Véges mező Diffie-Hellman (DHE) [TLS12]: legalább 2048 bit
A titkosítási csomag nem tiltott.

A TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 [TLS-ECDHE] alapértelmezés szerint támogatja az P-256 elliptikus görbét [FIPS186].

Az alábbi példa HTTP/1.1 és HTTP/2 kapcsolatokat engedélyez a 8000-s porton. A kapcsolatokat a TLS egy megadott tanúsítvánnyal védi:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
    });
});

Linuxon CipherSuitesPolicy használható a TLS-kézfogások kapcsolatonkénti szűrésére:

// using System.Net.Security;
// using Microsoft.AspNetCore.Hosting;
// using Microsoft.AspNetCore.Server.Kestrel.Core;
// using Microsoft.Extensions.DependencyInjection;
// using Microsoft.Extensions.Hosting;

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(listenOptions =>
    {
        listenOptions.OnAuthenticate = (context, sslOptions) =>
        {
            sslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(
                new[]
                {
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                    TlsCipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                    // ...
                });
        };
    });
});

Kapcsolat köztes szoftvere

A testreszabott kapcsolati köztes szoftver szükség esetén kapcsolatonként képes szűrni a TLS-kézfogásokat adott titkosítások esetén.

Az alábbi példa NotSupportedException ad minden olyan titkosítási algoritmushoz, amelyet az alkalmazás nem támogat. Másik lehetőségként definiálhatja és összehasonlíthatja ITlsHandshakeFeature.CipherAlgorithm az elfogadható titkosítási csomagok listájával.

Nem használ titkosítást CipherAlgorithmType.Null titkosítási algoritmussal.

// using System.Net;
// using Microsoft.AspNetCore.Connections;

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
        listenOptions.UseTlsFilter();
    });
});

using System;
using System.Security.Authentication;
using Microsoft.AspNetCore.Connections.Features;

namespace Microsoft.AspNetCore.Connections
{
    public static class TlsFilterConnectionMiddlewareExtensions
    {
        public static IConnectionBuilder UseTlsFilter(
            this IConnectionBuilder builder)
        {
            return builder.Use((connection, next) =>
            {
                var tlsFeature = connection.Features.Get<ITlsHandshakeFeature>();

                if (tlsFeature.CipherAlgorithm == CipherAlgorithmType.Null)
                {
                    throw new NotSupportedException("Prohibited cipher: " +
                        tlsFeature.CipherAlgorithm);
                }

                return next();
            });
        }
    }
}

A kapcsolatszűrés egy IConnectionBuilder lambdán keresztül is konfigurálható:

// using System;
// using System.Net;
// using System.Security.Authentication;
// using Microsoft.AspNetCore.Connections;
// using Microsoft.AspNetCore.Connections.Features;

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Listen(IPAddress.Any, 8000, listenOptions =>
    {
        listenOptions.UseHttps("testCert.pfx", "testPassword");
        listenOptions.Use((context, next) =>
        {
            var tlsFeature = context.Features.Get<ITlsHandshakeFeature>();

            if (tlsFeature.CipherAlgorithm == CipherAlgorithmType.Null)
            {
                throw new NotSupportedException(
                    $"Prohibited cipher: {tlsFeature.CipherAlgorithm}");
            }

            return next();
        });
    });
});

A HTTP-protokoll beállítása konfigurációból

CreateDefaultBuilder alapértelmezés szerint meghívja serverOptions.Configure(context.Configuration.GetSection("Kestrel"))Kestrel konfiguráció betöltéséhez.

Az alábbi appsettings.json példa a HTTP/1.1 protokollt hozza létre az összes végpont alapértelmezett kapcsolati protokolljaként:

{
  "Kestrel": {
    "EndpointDefaults": {
      "Protocols": "Http1"
    }
  }
}

Az alábbi appsettings.json példa a HTTP/1.1 kapcsolati protokollt hozza létre egy adott végponthoz:

{
  "Kestrel": {
    "Endpoints": {
      "HttpsDefaultCert": {
        "Url": "https://localhost:5001",
        "Protocols": "Http1"
      }
    }
  }
}

A konfiguráció által beállított kód felülbírálási értékekben megadott protokollok.

URL-előtagok

Csak a HTTP URL-előtagok érvényesek. Kestrel nem támogatja a HTTPS-t az URL-kötések UseUrlshasználatával történő konfigurálásakor.

IPv4-cím portszámmal
```
http://65.55.39.10:80/
```
0.0.0.0 egy speciális eset, amely az összes IPv4-címhez kötődik.
IPv6-cím portszámmal
```
http://[0:0:0:0:0:ffff:4137:270a]:80/
```
[::] az IPv4 0.0.0.0IPv6-megfelelője.
Hosztnév portszámmal
```
http://contoso.com:80/
http://*:80/
```
A hosztnevek, *és +, nem különlegesek. Az érvényes IP-címként nem felismert vagy localhost minden IPv4- és IPv6-IP-címhez kapcsolódik. Ha különböző gazdagépneveket szeretne különböző ASP.NET Core alkalmazásokhoz kötni ugyanazon a porton, használjon HTTP.sys vagy fordított proxykiszolgálót. A fordított proxykiszolgálók például az IIS, az Nginx vagy az Apache.

Figyelmeztetés

A fordított proxykonfigurációban való üzemeltetéshez szükség van gazdagépszűrésre.
Gazdagép localhost neve portszámmal vagy visszacsatolási IP-cím portszámmal
```
http://localhost:5000/
http://127.0.0.1:5000/
http://[::1]:5000/
```
Ha localhost van megadva, Kestrel IPv4- és IPv6-visszacsatolási felületekhez is megpróbál csatlakozni. Ha a kért portot egy másik szolgáltatás használja bármelyik visszacsatolási felületen, Kestrel nem indul el. Ha bármelyik visszacsatolási felület más okból nem érhető el (leggyakrabban azért, mert az IPv6 nem támogatott), Kestrel figyelmeztetést naplóz.

Megosztás a következőn keresztül:

Végpontok konfigurálása a ASP.NET Core Kestrel webkiszolgálóhoz

Alapértelmezett végpont

Végpontok konfigurálása

Végpontok konfigurálása URL-címekkel

URL-formátumok

HTTPS URL-előtagok

Csak portok megadása

Végpontok konfigurálása appsettings.json

Végpontok újratöltése konfigurációból

KonfigurációBetöltő

Végpontok konfigurálása a kódban

Kapcsolódás egy TCP-csatlakozóhoz

Kötés Unix-szoftvercsatornához

A végpont alapértelmezett beállításainak konfigurálása

Dinamikus portkötés

HTTPS konfigurálása

HTTPS konfigurálása appsettings.json

Sémajegyzetek

Tanúsítványforrások

Ügyféltanúsítványok konfigurálása a appsettings.json-ban

Az SSL-/TLS-protokollok konfigurálása a appsettings.json

HTTPS konfigurálása kódban

Ügyféltanúsítványok konfigurálása kódban

HTTPS-alapértelmezett beállítások konfigurálása a kódban

SSL-/TLS-protokollok konfigurálása kódban

TLS-titkosítási csomagok szűrőjének konfigurálása kódban

Kiszolgálónév-jelzés konfigurálása

Konfigurálja az SNI-t a appsettings.json-ban

SNI konfigurálása kóddal

SNI ServerCertificateSelector

SNI ServerOptionsSelectionCallback

SNI TlsHandshakeCallbackOptions-val

HTTP-protokollok konfigurálása

HTTP-protokollok konfigurálása a appsettings.json

HTTP-protokollok konfigurálása kódban

Lásd még:

ConfigureEndpointDefaults

Konfigurálás(IConfiguration)

HttpsDefaults konfigurálása

ListenOptions.UseHttps

Nincs konfiguráció

Az alapértelmezett tanúsítvány cseréje a konfigurációból

Tanúsítványforrások

Konfiguráció Betöltő

Az alapértelmezett értékek módosítása a kódban

Végpontok konfigurálása kiszolgálónév-jelzéssel

SNI ServerCertificateSelector-val

SNI ServerOptionsSelectionCallback-val

SNI TlsHandshakeCallbackOptions-vel

SNI konfigurációban

SNI-követelmények

SSL-/TLS-protokollok

Ügyféltanúsítványok

Kapcsolatnaplózás

Kötés TCP-szoftvercsatornához

Kötés egy Unix sockethez

0 port

Korlátozások

IIS-végpont konfigurálása

ListenOptions.Protocols

Kapcsolat köztes szoftvere

A HTTP-protokoll beállítása konfigurációból

URL-előtagok

Végpont Alapértelmezések Beállítása

Konfigurálás(IConfiguration)

HttpsDefaults konfigurálása

ListenOptions.UseHttps

Nincs konfiguráció

Az alapértelmezett tanúsítvány cseréje a konfigurációból

Tanúsítványforrások

Konfigurációbetöltő

Az alapértelmezett értékek módosítása a kódban

Végpontok konfigurálása kiszolgálónév-jelzéssel

SNI ServerCertificateSelector

SNI ServerOptionsSelectionCallback

SNI TlsHandshakeCallbackOptions

SNI a konfigurációban

SNI-követelmények

SSL-/TLS-protokollok

SNI `ServerCertificateSelector`

SNI `ServerOptionsSelectionCallback`

SNI `TlsHandshakeCallbackOptions`-val

SNI `ServerCertificateSelector`-val

SNI `ServerOptionsSelectionCallback`-val

SNI `TlsHandshakeCallbackOptions`-vel

SNI `ServerCertificateSelector`

SNI `ServerOptionsSelectionCallback`

SNI `TlsHandshakeCallbackOptions`

SNI `ServerCertificateSelector`

SNI `ServerOptionsSelectionCallback`