HTTPS i ASP.NET kärna från början

nyligen när man tittar på hur man konfigurerar autentisering med externa inloggningsleverantörer (t. ex. Google, Facebook) med ASP.NET Core jag märkte att https nu är ett krav för några av dem.

en annan sak jag märkte var hur svårt det var att hitta resurser om att aktivera HTTPS på ASP.NET kärna.

detta blogginlägg handlar om processen att skapa en lokal ASP.NET Core-webbplats som körs med HTTPS utan fel i Chrome (visar det gröna hänglåset i adressfältet) för din lokala utvecklingstid. Och sedan hur du kan använda Nginx eller IIS när du är redo att exponera den för världen.

för att kunna använda HTTPS behöver vi ett digitalt certifikat. Om du behöver skapa din egen att använda vid utvecklingstid rekommenderar jag att du använder OpenSSL för att skapa certifikat. Det förklarar inte bara hur du kan skapa din egen certifikatutfärdare och certifikat, utan också hur du kan konfigurera din webbläsare (Chrome eller Firefox) för att lita på certifikatutfärdaren.

dessutom, om du vill förstå vad som är rollen av certifikat i HTTPS, sedan ta en titt på kort(ish) förklaring av hur https fungerar.

från och med nu antar jag att du har genererat din certifikatutfärdare, certifikat och motsvarande privat nyckel och du har en .PFX (personlig informationsutbyte) fil.

skapa ett nytt projekt

jag kommer att beskriva processen med Visual Studio Code och Yeoman.

om du inte är bekant med yeoman är det ett kommandoradsverktyg som låter dig skapa nya projekt från en lista med projektmallar. Yeoman-generatorn (det är namnet på paketet för yeoman som innehåller mallarna) vi ska använda är generator-aspnet. För att installera yeoman behöver du först npm och sedan kan du följa instruktionerna för att installera yeoman och ASP.NET kärn mallar här.

anledningen till att använda Visual Studio Code och yeoman är att denna process fungerar på Windows, Linux och macOS.

att använda yeoman med ASP.NET Kärnmallar kör följande kommando:

$ yo aspnet _-----_ ╭──────────────────────────╮ | | │ Welcome to the │ |--(o)--| │ marvellous ASP.NET Core │`---------´ │ generator! │ ( _´U`_ ) ╰──────────────────────────╯ /___A___\ / | ~ | __'.___.'__ ´ ` |° ´ Y ` ? What type of application do you want to create? (Use arrow keys)❯ Empty Web Application Empty Web Application (F#) Console Application Console Application (F#) Web Application Web Application Basic Web Application Basic (F#) 

välj Tom webbapplikation. Ett enkelt webbprojekt kommer att skapas som bara har sida med texten ”Hello World”.

om du kör Windows och har den fullständiga versionen av Visual Studio kan du bara göra fil -> nytt projekt, välj. Net Core, ASP.NET kärna webbapplikation och välj sedan tom.

konfigurera HTTPS för Kestrel

Kestrel är webbservern som används som standard med ASP.NET kärna.

för att lägga till HTTPS-stöd i Kestrel, Lägg till paketet Microsoft.AspNetCore.Server.Kestrel.Https som ett beroende.

om du använder project.json du kan göra detta genom att redigera projekt.jsons avsnitt ”beroenden” och lägger till:

"Microsoft.AspNetCore.Server.Kestrel.Https": "1.1.0"

versionsnumret kan vara annorlunda för dig, men det borde vara detsamma som det som används i paketet Microsoft.AspNetCore.Server.Kestrel.

om du använder .csproj kan du lägga till beroendet genom att köra:

dotnet add package Microsoft.AspNetCore.Server.Kestrel.Https

Certifikatkonfiguration

för att konfigurera Kestrel för att använda vår .pfx-fil (certifikat och privat nyckel) Vi måste redigera Program.cs där WebHostBuilder skapas och göra några ändringar:

var host = new WebHostBuilder() .UseConfiguration(config) .UseKestrel(options => { options.UseHttps("localhost.pfx", "password"); }) .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseUrls("https://*:4430") .UseStartup<Startup>() .Build();

förändringarna är:

.UseKestrel(options => { options.UseHttps("localhost.pfx", "password");})

det är där vi anger vad som är .pfx-fil som vi vill använda och dess lösenord. UseHttps är en förlängningsmetod, om du får ett fel som säger att det inte existerar beror det på att du inte lade till paketet Microsoft.AspNetCore.Server.Kestrel.Https nuget, vilket är där det bor.

också:

.UseUrls("https://*:4430")

som definierar var Kestrel kommer att lyssna på inkommande anslutningar. Alternativt kan du använda https://localhost:4430 istället för *. Med * kan du dock använda vilket domännamn som helst, till exempel om du har den här webbapplikationen i myDomain.com skulle det fortfarande fungera, medan med localhost skulle endast förfrågningar till localhost serveras.

om du undrar varför jag inte använde standard HTTPS-porten, 443, beror det på att du behöver speciella behörigheter på Linux för portar under 1024. I Windows skulle detta inte vara ett problem. Men eftersom det bara rekommenderas att göra detta med Kestrel när du är på utvecklingstid är det inte ett stort problem.

om du försöker detta i Linux, macOS eller använder kommandoraden i Windows kan du ringa dotnet run, öppna Chrome och gå till https://localhost:43000 och se en grön hänglåsikon.

om du använder Full Visual Studio i Windows är sättet att göra detta att ange att du vill köra webbapplikationen direkt och inte via IIS Express:

välj också den webbläsare du vill prova på. Om du har installerat din test root certificate authority certifikat i en viss webbläsare, använd den webbläsaren, till exempel Chrome (om du är förvirrad av detta uttalande rekommenderar jag att du läser kort (ish) förklaring av hur https fungerar och Använder OpenSSL för att skapa certifikat):

slutligen redigera projektegenskaperna (högerklicka och välj Egenskaper):

och ändra startadressen:

använda ASP.NET kärna med en omvänd proxy

även om det verkligen är möjligt att betjäna en webbapplikation med ASP.NET kärna med endast Kestrel, det rekommenderas inte. Detta beror på att Kestrel inte är en fullt utrustad webbserver och fortfarande saknar vissa säkerhetsfunktioner.

även om det inte rekommenderas kanske du bara vill visa något du har gjort för någon och hoppa över delen av att installera och konfigurera en webbserver. Med tjänster som DigitalOcean eller Linode kan du skapa en VPS på mycket kort tid och bara ha din ASP.NET Core tillgänglig genom det bara behöva installera.Net core.

men om du vill ha något mer allvarligt (och du förmodligen gör eftersom du är här på grund av att aktivera HTTPS) bör du använda en fullfjädrad webbserver, som Nginx eller IIS (i Windows), som en omvänd proxy till din ASP.NET Kärnapplikation.

en omvänd proxyserver är en webbserver som accepterar förfrågningar och skickar dem till en annan webbserver som faktiskt skapar svaren för dessa förfrågningar. Svaren skickas tillbaka till proxyservern som vidarebefordrar dem till de klienter som utfärdade motsvarande förfrågningar.

med Nginx som en omvänd proxy skulle det se ut så här:

Browser <----> Nginx <----> Kestrel

det bra med denna inställning är att vi kan dra nytta av att Nginx (eller IIS) är en fullständig webbserver och aktivera HTTPS på den:

Browser <---- HTTPS ---> Nginx <---- HTTP ----> Kestrel

så vi behöver inte ens konfigurera Kestrel med HTTPS, bara Nginx.

konfigurera HTTPS med Nginx

först måste du installera Nginx. Jag använder Ubuntu 16.04 för detta, men du kan även installera det på Windows.

om du kör Ubuntu öppnar du en terminal och skriver

$ sudo apt-get install nginx

nästa sak vi behöver göra är att redigera nginx konfiguration. Men innan vi gör det är det bra att veta vad som är platsen för konfigurationsfilerna och hur de blir aktiverade. Mappen där konfigurationsfilerna vanligtvis placeras är /etc/nginx/sites-available/ (den här platsen kan vara annorlunda om du använder en annan Linux-distribution).

konfigurationsfilen som finns när du installerar Nginx heter default.

för att en nginx-konfiguration ska bli aktiverad måste den finnas i mappen /etc/nginx/sites-enabled. Så efter att ha skapat en ny konfigurationsfil (i sites-available) skapas en symbolisk länk i sites-enabled som pekar på den nya filen.

Föreställ dig att vi just hade skapat en ny konfigurationsfil med namnet my-site-https i sites-available. Därefter går du till mappen sites-enabled och kör följande kommando för att skapa en symbolisk länk:

$ ln -s /etc/nginx/sites-available/my-site-htts

för att få Nginx att läsa den här nya konfigurationen kör kommandot:

$ sudo nginx -s reload

nu när vi vet hur man skapar och aktiverar nginx-konfigurationer, låt oss skapa konfigurationsfilen för att konfigurera Nginx som en omvänd proxy till en ASP.NET Kärnapplikation som körs på http://localhost:5000.

skapa först en ny fil i /etc/nginx/sites-available med namnet, till exempel aspnetcore, med följande innehåll:

server { listen 443 ssl; ssl_certificate PATH_TO_CERTIFICATE/CERTIFICATE_NAME.pem; ssl_certificate_key PATH_TO_PRIVATE_KEY/PRIVATE_KEY.pem; location / { proxy_pass http://localhost:5000; }}

här konfigurerar vi Nginx till listen till port 443 med SSL (443 är standard för HTTPS). Därefter specificerar vi var certifikatet (ssl_certificate) och privat nyckel (ssl_certificate_key) finns och slutligen instruerar vi Nginx att vidarebefordra alla förfrågningar (location / matchar alla förfrågningar) till http://localhost:5000.

slutligen skapa den symboliska länken till den här filen i sites-enabled (du kan ta bort länken till filen default, det här tar inte bort originalfilen eftersom det är en symbolisk länk).

/etc/nginx/sites-enabled$ sudo ln -s /etc/nginx/sites-available/aspnetcore

för att göra Nginx ladda denna konfiguration:

$ sudo nginx -s reload

om du har din ASP.NET Kärnapplikation som körs på http://localhost:5000 du bör nu kunna öppna https://localhost och se att den serveras över HTTPS.

det finns ett vanligt problem som kan hända när du laddar om Nginx-konfigurationen, vilket är att du blir uppmanad till ett lösenord. Specifikt för privat nyckel lösenord. Det här kanske inte är praktiskt för dig, så om du vill ta bort lösenordet från den privata nyckeln kan du köra följande kommando:

$ openssl rsa -in privateKeyWithPassword.pem -out privateKeyWithoutPassword.pem

en annan användbar sak du kan göra med Nginx är att alla förfrågningar till HTTP omdirigeras till HTTPS. Om du vill aktivera detta lägg till den här extra konfigurationen till dig aspnetcore nginx konfigurationsfil:

server { listen 80; return 301 https://$host$request_uri;}

konfigurera handledare

en sak vi måste oroa oss för är att vi måste behålla vår ASP.NET Core webbapplikation som körs.

det finns ett verktyg som heter supervisor som tillåter oss att konfigurera att ett program ska initieras vid starttid, och om det kraschar bör det tas tillbaka

det första vi behöver göra är att installera det. Jag använder Ubuntu 16.04 för detta, och i den här distributionen är installationen väldigt enkel:

$ sudo apt-get install supervisor

nästa sak vi behöver göra är att skapa en handledarkonfigurationsfil för vår webbapplikation. Låt oss kalla det aspnetcore.conf och Lägg till det i /etc/supervisor/conf.d(du måste göra det med sudo):

placera detta i konfigurationsfilen:

command=/usr/bin/dotnet PATH_TO_YOUR_PUBLISHED_PROJECT/YOURWEBAPP.dlldirectory=PATH_TO_YOUR_PUBLISHED_PROJECTautostart=trueautorestart=truestdout_logfile=/var/log/aspnetcore.out.logstderr_logfile=/var/log/aspnetcore.err.logenvironment=ASPNETCORE_ENVIRONMENT="Production"

den första raden definierar namnet (aspnetcore) som vi kan hänvisa till webbapplikationen i supervisor.

raden med command definierar kommandot som ska köras. I det här fallet är det dotnet följt av din webbapplikations dll. Detta motsvarar att köra dotnet run i roten till ditt projekt.

nästa rad (directory=) anger arbetskatalogen som den där ditt projekt finns.

autostart=true betyder att applikationen startas vid starttid.

autorestart=true betyder att programmet startas om om det kraschar eller till och med om det stoppas (till exempel med kill). Om du vill att din ansökan endast ska startas om i händelse av en krasch, ändra den till autorestart=unexpected.

de följande två raderna definierar till vilka filer standard-och felutmatningen skrivs till.

slutligen environment tillåter oss att ställa in miljövariabler, i det här fallet ställer vi in ASPNETCORE_ENVIRONMENT=Production.

för att aktivera den här nya konfigurationsfilen kör följande kommandon:

$ sudo supervisorctl reread$ sudo supervisorctl update

du kan kontrollera status för de processer som körs under supervisor genom att köra

$ sudo supervisorctl

det ska visa något som liknar:

aspnetcore kör pid 18817, upptid 0:05:29
supervisor>

det finns flera flera kommandon som du kan använda för att hantera processer under handledare, skriv help för en lista över tillgängliga kommandon. För att avsluta, skriv bara quit.

konfigurera HTTPS med IIS

det första steget i att aktivera HTTPS när du använder IIS är att installera vårt certifikat och privata nyckel (med a .PFX-fil som innehåller båda).

öppna IIS-hanteraren och välj servercertifikat

klicka på Importera certifikat:

Välj .PFX-fil och ange motsvarande lösenord, lämna butiken som personlig:

innan vi fortsätter är det viktigt att nämna att du måste ha ASP.NET kärnmodul installerad. Det är mycket troligt att du redan gör eftersom det är installerat för dig när du installerar.Net Core SDK.

men om det inte är (du kan verifiera det i IIS Manager genom att öppna moduler och kontrollera om AspNetCoreModule finns där), du kan hitta installationsanvisningar här och en direktlänk för nedladdning av ASP.NET Core Server Hosting Bundle här.

vad denna modul gör är att starta din ASP.NET Kärnwebbplats och håll den igång (Starta om den om den kraschar). Den här modulen ansvarar också för att vidarebefordra HTTP-förfrågningarna till din webbapp och sedan vidarebefordra svaren till klienten.

en viktig sak att veta om AspNetCoreModule är att den är konfigurerad av filen web.config i roten till ditt projekt. Du måste köra dotnet publish på ditt projekt för att få web.config setup korrekt i din publiceringsmapp.

nästa steg är att skapa en ny Applikationspool och välja Ingen hanterad kod som.Net CLR-versionen. Normalt körs webbplatserna i en IIS-arbetsprocess, men i. NET Core körs de som en separat process, så det finns inget behov av en. NET-Runtime i apppoolen:

slutligen, låt oss skapa en ny webbplats inuti IIS för vår ASP.NET Kärnapplikation. Vi måste välja den apppool vi just har skapat, Välj som den fysiska sökvägen till den publicerade webbplatsen, välj HTTPS som bindning och vårt certifikat i rullgardinsmenyn SSL-certifikat:

du bör nu kunna använda https för att bläddra till din ASP.NET kärn app.