Il modo migliore in asp.net per forzare https per un intero sito?

Circa 6 mesi fa ho implementato un sito in cui ogni richiesta doveva essere superiore a HTTPS. L'unico modo in quel momento in cui sono riuscito a trovare per assicurarsi che ogni richiesta a una pagina fosse su https era di controllarlo nell'evento di caricamento della pagina. Se la richiesta non fosse su http vorrei response.redirect (" https://example.com ")

C'è un modo migliore - idealmente qualche impostazione in web.config?

Utilizzare HSTS (HTTP Strict Transport Security)

da http://www.hanselman.com/blog/HowToEnableHTTPStrictTransportSecurityHSTSInIIS7.aspx

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <system.webServer>
        <rewrite>
            <rules>
                <rule name="HTTP to HTTPS redirect" stopProcessing="true">
                    <match url="(.*)" />
                    <conditions>
                        <add input="{HTTPS}" pattern="off" ignoreCase="true" />
                    </conditions>
                    <action type="Redirect" url="https://{HTTP_HOST}/{R:1}"
                        redirectType="Permanent" />
                </rule>
            </rules>
            <outboundRules>
                <rule name="Add Strict-Transport-Security when HTTPS" enabled="true">
                    <match serverVariable="RESPONSE_Strict_Transport_Security"
                        pattern=".*" />
                    <conditions>
                        <add input="{HTTPS}" pattern="on" ignoreCase="true" />
                    </conditions>
                    <action type="Rewrite" value="max-age=31536000" />
                </rule>
            </outboundRules>
        </rewrite>
    </system.webServer>
</configuration>

Risposta originale (sostituita dalla precedente il 4 dicembre 2015)

fondamentalmente

protected void Application_BeginRequest(Object sender, EventArgs e)
{
   if (HttpContext.Current.Request.IsSecureConnection.Equals(false) && HttpContext.Current.Request.IsLocal.Equals(false))
   {
    Response.Redirect("https://" + Request.ServerVariables["HTTP_HOST"]
+   HttpContext.Current.Request.RawUrl);
   }
}

che andrebbe in global.asax.cs (o global.asax.vb)

non conosco un modo per specificarlo in web.config

L'altra cosa che puoi fare è utilizzare HSTS restituendo l'intestazione "Strict-Transport-Security" al browser. Il browser deve supportare questo (e attualmente lo sono principalmente Chrome e Firefox), ma significa che una volta impostato, il browser non farà richieste al sito su HTTP e le tradurrà invece in richieste HTTPS prima di emetterle . Prova questo in combinazione con un reindirizzamento da HTTP:

protected void Application_BeginRequest(Object sender, EventArgs e)
{
  switch (Request.Url.Scheme)
  {
    case "https":
      Response.AddHeader("Strict-Transport-Security", "max-age=300");
      break;
    case "http":
      var path = "https://" + Request.Url.Host + Request.Url.PathAndQuery;
      Response.Status = "301 Moved Permanently";
      Response.AddHeader("Location", path);
      break;
  }
}

I browser che non sono a conoscenza di HSTS ignoreranno semplicemente l'intestazione ma saranno comunque catturati dall'istruzione switch e inviati a HTTPS.

Il modulo IIS7 ti permetterà di reindirizzare.

    <rewrite>
        <rules>
            <rule name="Redirect HTTP to HTTPS" stopProcessing="true">
                <match url="(.*)"/>
                <conditions>
                    <add input="{HTTPS}" pattern="^OFF$"/>
                </conditions>
                <action type="Redirect" url="https://{HTTP_HOST}/{R:1}" redirectType="SeeOther"/>
            </rule>
        </rules>
    </rewrite>

Per coloro che utilizzano ASP.NET MVC. È possibile utilizzare quanto segue per imporre SSL / TLS su HTTPS sull'intero sito in due modi:

The Hard Way

1 - Aggiungi RequireHttpsAttribute ai filtri globali:

GlobalFilters.Filters.Add(new RequireHttpsAttribute());

2 - Forza token anti-contraffazione per utilizzare SSL / TLS:

AntiForgeryConfig.RequireSsl = true;

3 - Richiede i cookie per richiedere HTTPS per impostazione predefinita modificando il file Web.config:

<system.web>
    <httpCookies httpOnlyCookies="true" requireSSL="true" />
</system.web>

4 - Utilizzare il pacchetto NuGet NWebSec.Owin e aggiungere la seguente riga di codice per abilitare Strict Transport Security attraverso il sito. Non dimenticare di aggiungere la direttiva Preload di seguito e inviare il tuo sito al sito HSTS Preload . Maggiori informazioni qui e qui . Si noti che se non si utilizza OWIN, esiste un metodo Web.config che è possibile leggere sul sito NWebSec .

// app is your OWIN IAppBuilder app in Startup.cs
app.UseHsts(options => options.MaxAge(days: 30).Preload());

5 - Utilizzare il pacchetto NuGet NWebSec.Owin e aggiungere la seguente riga di codice per abilitare Pinning chiave pubblica (HPKP) in tutto il sito. Maggiori informazioni qui e qui .

// app is your OWIN IAppBuilder app in Startup.cs
app.UseHpkp(options => options
    .Sha256Pins(
        "Base64 encoded SHA-256 hash of your first certificate e.g. cUPcTAZWKaASuYWhhneDttWpY3oBAkE3h2+soZS7sWs=",
        "Base64 encoded SHA-256 hash of your second backup certificate e.g. M8HztCzM3elUxkcjR2S5P4hhyBNf6lHkmjAHKhpGPWE=")
    .MaxAge(days: 30));

6 - Includi lo schema https negli URL utilizzati. L' intestazione HTTP e l'Integrità delle risorse secondarie (SRI) di Content Security Policy (CSP) non funzionano bene quando si imita lo schema in alcuni browser. È meglio essere espliciti su HTTPS. per esempio

<script src="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.4/bootstrap.min.js"></script>

Il modo più semplice

Utilizzare il modello di progetto ASP.NET MVC Boilerplate Visual Studio per generare un progetto con tutto questo e molto altro ancora incorporato. È inoltre possibile visualizzare il codice su GitHub .

Se non riesci a configurarlo in IIS per qualsiasi motivo, creerei un modulo HTTP che esegue il reindirizzamento per te:

using System;
using System.Web;

namespace HttpsOnly
{
    /// <summary>
    /// Redirects the Request to HTTPS if it comes in on an insecure channel.
    /// </summary>
    public class HttpsOnlyModule : IHttpModule
    {
        public void Init(HttpApplication app)
        {
            // Note we cannot trust IsSecureConnection when 
            // in a webfarm, because usually only the load balancer 
            // will come in on a secure port the request will be then 
            // internally redirected to local machine on a specified port.

            // Move this to a config file, if your behind a farm, 
            // set this to the local port used internally.
            int specialPort = 443;

            if (!app.Context.Request.IsSecureConnection 
               || app.Context.Request.Url.Port != specialPort)
            {
               app.Context.Response.Redirect("https://" 
                  + app.Context.Request.ServerVariables["HTTP_HOST"] 
                  + app.Context.Request.RawUrl);    
            }
        }

        public void Dispose()
        {
            // Needed for IHttpModule
        }
    }
}

Quindi compilalo in una DLL, aggiungilo come riferimento al tuo progetto e inseriscilo in web.config:

 <httpModules>
      <add name="HttpsOnlyModule" type="HttpsOnly.HttpsOnlyModule, HttpsOnly" />
 </httpModules>

Quello che devi fare è:

1) Aggiungere una chiave all'interno di web.config, a seconda del server di produzione o stage come di seguito

<add key="HttpsServer" value="stage"/>
             or
<add key="HttpsServer" value="prod"/>

2) All'interno del tuo file Global.asax aggiungi il metodo seguente.

void Application_BeginRequest(Object sender, EventArgs e)
{
    //if (ConfigurationManager.AppSettings["HttpsServer"].ToString() == "prod")
    if (ConfigurationManager.AppSettings["HttpsServer"].ToString() == "stage")
    {
        if (!HttpContext.Current.Request.IsSecureConnection)
        {
            if (!Request.Url.GetLeftPart(UriPartial.Authority).Contains("www"))
            {
                HttpContext.Current.Response.Redirect(
                    Request.Url.GetLeftPart(UriPartial.Authority).Replace("http://", "https://www."), true);
            }
            else
            {
                HttpContext.Current.Response.Redirect(
                    Request.Url.GetLeftPart(UriPartial.Authority).Replace("http://", "https://"), true);
            }
        }
    }
}

Se il supporto SSL non è configurabile nel tuo sito (ad es. Dovrebbe essere in grado di attivare / disattivare https) - puoi utilizzare l'attributo [RequireHttps] su qualsiasi azione controller / controller che desideri proteggere.

Dipende anche dalla marca del tuo bilanciatore, per il web mux, dovresti cercare l'intestazione http X-WebMux-SSL-termination: trueper capire che il traffico in entrata era SSL. dettagli qui: http://www.cainetworks.com/support/redirect2ssl.html

Per @Joe sopra, "Questo mi sta dando un ciclo di reindirizzamento. Prima di aggiungere il codice ha funzionato bene. Qualche suggerimento? - Joe 8 novembre 11 alle 4:13"

Ciò stava accadendo anche a me e ciò che credo stia accadendo è che c'era un bilanciamento del carico che stava terminando la richiesta SSL di fronte al server Web. Quindi, il mio sito Web ha sempre pensato che la richiesta fosse "http", anche se il browser originale aveva richiesto che fosse "https".

Devo ammettere che è un po 'confuso, ma ciò che ha funzionato per me è stato implementare una proprietà "JustRedirected" che avrei potuto sfruttare per capire che la persona era già reindirizzata una volta. Quindi, collaudo condizioni specifiche che giustificano il reindirizzamento e, se sono soddisfatte, ho impostato questa proprietà (valore memorizzato nella sessione) prima del reindirizzamento. Anche se le condizioni http / https per il reindirizzamento vengono soddisfatte la seconda volta, ignoro la logica di reindirizzamento e reimposto il valore della sessione "JustRedirected" su false. Avrai bisogno della tua logica di test condizionale, ma ecco una semplice implementazione della proprietà:

    public bool JustRedirected
    {
        get
        {
            if (Session[RosadaConst.JUSTREDIRECTED] == null)
                return false;

            return (bool)Session[RosadaConst.JUSTREDIRECTED];
        }
        set
        {
            Session[RosadaConst.JUSTREDIRECTED] = value;
        }
    }

Ho intenzione di buttare dentro i miei due centesimi. SE hai accesso al lato server IIS, puoi forzare HTTPS usando i binding di protocollo. Ad esempio, hai un sito web chiamato Blah . In IIS avresti impostato due siti: Blah e Blah (Redirect) . Per Blah configura solo il HTTPSbinding (e, FTPse necessario, assicurati di forzarlo anche su una connessione sicura). Per Blah (Redirect) configura solo l' HTTPassociazione. Infine, nella sezione Reindirizzamento HTTP per Blah (Reindirizzamento) assicurati di impostare un reindirizzamento 301 su https://blah.com, con destinazione esatta abilitata. Assicurarsi che ogni sito in IIS stia puntando a esso propria cartella radice, altrimenti Web.config verrà rovinato. Assicurati anche di averloHSTS configurato sul sito HTTPS in modo che le richieste successive da parte del browser siano sempre forzate su HTTPS e non si verifichino reindirizzamenti.

Questa è una risposta più completa basata su @Troy Hunt's. Aggiungi questa funzione alla tua WebApplicationclasse in Global.asax.cs:

    protected void Application_BeginRequest(Object sender, EventArgs e)
    {
        // Allow https pages in debugging
        if (Request.IsLocal)
        {
            if (Request.Url.Scheme == "http")
            {
                int localSslPort = 44362; // Your local IIS port for HTTPS

                var path = "https://" + Request.Url.Host + ":" + localSslPort + Request.Url.PathAndQuery;

                Response.Status = "301 Moved Permanently";
                Response.AddHeader("Location", path);
            }
        }
        else
        {
            switch (Request.Url.Scheme)
            {
                case "https":
                    Response.AddHeader("Strict-Transport-Security", "max-age=31536000");
                    break;
                case "http":
                    var path = "https://" + Request.Url.Host + Request.Url.PathAndQuery;
                    Response.Status = "301 Moved Permanently";
                    Response.AddHeader("Location", path);
                    break;
            }
        }
    }

(Per abilitare SSL sulla build locale abilitarlo nel dock Proprietà per il progetto)

-> Aggiungi semplicemente [RequireHttps] in cima alla HomeController di classe pubblica: Controller.

-> E aggiungi GlobalFilters.Filters.Add (new RequireHttpsAttribute ()); nel metodo "protetto void Application_Start ()" nel file Global.asax.cs.

Ciò forza la tua intera applicazione su HTTPS.

Ho trascorso qualche tempo a cercare le migliori pratiche che abbiano un senso e ho trovato quanto segue che ha funzionato perfettamente per me. Spero che questo ti salverà qualche volta.

Utilizzo del file di configurazione (ad esempio un sito Web asp.net) https://blogs.msdn.microsoft.com/kaushal/2013/05/22/http-to-https-redirects-on-iis-7-x-and- più alto/

o sul tuo server https://www.sslshopper.com/iis7-redirect-http-to-https.html

[RISPOSTA CORTA] Semplicemente Il codice qui sotto entra

<system.webServer> 
 <rewrite>
     <rules>
       <rule name="HTTP/S to HTTPS Redirect" enabled="true" 
           stopProcessing="true">
       <match url="(.*)" />
        <conditions logicalGrouping="MatchAny">
        <add input="{SERVER_PORT_SECURE}" pattern="^0$" />
       </conditions>
       <action type="Redirect" url="https://{HTTP_HOST}{REQUEST_URI}" 
        redirectType="Permanent" />
        </rule>
       </rules>
 </rewrite>

In IIS10 (Windows 10 e Server 2016), dalla versione 1709 in poi, esiste una nuova opzione più semplice per abilitare HSTS per un sito Web.

Microsoft descrive i vantaggi del nuovo approccio qui , e di fornire molti esempi diversi di come implementare la modifica a livello di codice o modificando direttamente il file ApplicationHost.config (che è come web.config, ma opera a livello IIS, piuttosto che a livello di singolo sito ). ApplicationHost.config è disponibile in C: \ Windows \ System32 \ inetsrv \ config.

Ho delineato due dei metodi di esempio qui per evitare il marciume dei link.

Metodo 1 - Modifica direttamente il file ApplicationHost.config Tra i <site>tag, aggiungi questa riga:

<hsts enabled="true" max-age="31536000" includeSubDomains="true" redirectHttpToHttps="true" />

Metodo 2 - Riga di comando: eseguire quanto segue da un prompt dei comandi con privilegi elevati (ad es. Mouse destro su CMD ed eseguire come amministratore). Ricorda di scambiare Contoso con il nome del tuo sito come appare in Gestione IIS.

c:
cd C:\WINDOWS\system32\inetsrv\
appcmd.exe set config -section:system.applicationHost/sites "/[name='Contoso'].hsts.enabled:True" /commit:apphost
appcmd.exe set config -section:system.applicationHost/sites "/[name='Contoso'].hsts.max-age:31536000" /commit:apphost
appcmd.exe set config -section:system.applicationHost/sites "/[name='Contoso'].hsts.includeSubDomains:True" /commit:apphost
appcmd.exe set config -section:system.applicationHost/sites "/[name='Contoso'].hsts.redirectHttpToHttps:True" /commit:apphost

Gli altri metodi offerti da Microsoft in quegli articoli potrebbero essere opzioni migliori se ti trovi in ​​un ambiente ospitato in cui hai accesso limitato.

Tieni presente che IIS10 versione 1709 è ora disponibile su Windows 10, ma per Windows Server 2016 si trova su una traccia di rilascio diversa e non verrà rilasciato come patch o service pack. Vedi qui per i dettagli sul 1709.

Se si utilizza ASP.NET Core, è possibile provare il pacchetto nuget SaidOut.AspNetCore.HttpsWithStrictTransportSecurity.

Quindi devi solo aggiungere

app.UseHttpsWithHsts(HttpsMode.AllowedRedirectForGet, configureRoutes: routeAction);

Questo aggiungerà anche l'intestazione HTTP StrictTransportSecurity a tutte le richieste fatte usando lo schema https.

Codice di esempio e documentazione https://github.com/saidout/saidout-aspnetcore-httpswithstricttransportsecurity#example-code