Come scoprire se stai usando HTTPS senza $ _SERVER ['HTTPS']

Ho visto molti tutorial online che dicono che è necessario verificare $_SERVER['HTTPS']se il server è la connessione è protetta con HTTPS. Il mio problema è che su alcuni dei server che uso, $_SERVER['HTTPS']è una variabile indefinita che provoca un errore. C'è un'altra variabile che posso controllare che dovrebbe sempre essere definita?

Per essere chiari, sto attualmente usando questo codice per risolvere se si tratta di una connessione HTTPS:

if(isset($_SERVER['HTTPS'])) {
    if ($_SERVER['HTTPS'] == "on") {
        $secure_connection = true;
    }
}

Questo dovrebbe funzionare sempre anche quando $_SERVER['HTTPS']non è definito:

function isSecure() {
  return
    (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off')
    || $_SERVER['SERVER_PORT'] == 443;
}

Il codice è compatibile con IIS.

Dalla documentazione di PHP.net e commenti degli utenti :

1) Impostato su un valore non vuoto se lo script è stato interrogato tramite il protocollo HTTPS.

2) Notare che quando si utilizza ISAPI con IIS, il valore sarà "off" se la richiesta non è stata effettuata tramite il protocollo HTTPS. (Lo stesso comportamento è stato segnalato per IIS7 che esegue PHP come applicazione Fast-CGI).

Inoltre, i server Apache 1.x (e le installazioni non funzionanti) potrebbero non essere stati $_SERVER['HTTPS']definiti anche se connessi in modo sicuro. Sebbene non garantiti, le connessioni sulla porta 443 stanno, per convenzione , probabilmente utilizzando socket sicuri , quindi il controllo della porta aggiuntiva.

Nota aggiuntiva: se esiste un bilanciamento del carico tra il client e il server, questo codice non verifica la connessione tra il client e il bilanciamento del carico, ma la connessione tra il bilanciamento del carico e il server. Per testare la precedente connessione, dovresti testare usando l' HTTP_X_FORWARDED_PROTOintestazione, ma è molto più complesso da fare; vedi gli ultimi commenti sotto questa risposta.

La mia soluzione (poiché le condizioni standard [$ _SERVER ['HTTPS'] == 'on'] non funzionano sui server dietro un bilanciamento del carico) sono:

$isSecure = false;
if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') {
    $isSecure = true;
}
elseif (!empty($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https' || !empty($_SERVER['HTTP_X_FORWARDED_SSL']) && $_SERVER['HTTP_X_FORWARDED_SSL'] == 'on') {
    $isSecure = true;
}
$REQUEST_PROTOCOL = $isSecure ? 'https' : 'http';

HTTP_X_FORWARDED_PROTO: uno standard di fatto per identificare il protocollo di origine di una richiesta HTTP, poiché un proxy inverso (bilanciamento del carico) può comunicare con un server Web utilizzando HTTP anche se la richiesta per il proxy inverso è HTTPS http: //en.wikipedia. org / wiki / List_of_HTTP_header_fields # Common_non-standard_request_headers

Chacha, secondo la documentazione di PHP: "Impostato su un valore non vuoto se lo script è stato interrogato tramite il protocollo HTTPS." Quindi la tua dichiarazione if ci restituirà false in molti casi in cui HTTPS è effettivamente attivo. Ti consigliamo di verificare che $_SERVER['HTTPS']esiste e non è vuoto. Nei casi in cui HTTPS non è impostato correttamente per un determinato server, puoi provare a verificare se $_SERVER['SERVER_PORT'] == 443.

Tuttavia, alcuni server imposteranno anche $_SERVER['HTTPS']un valore non vuoto, quindi assicurati di controllare anche questa variabile.

Riferimento: documentazione per $_SERVERe $HTTP_SERVER_VARS[obsoleto]

Questo funziona anche quando $_SERVER['HTTPS']non è definito

if( (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off') || $_SERVER['SERVER_PORT'] == 443 ){
    //enable secure connection
}

Ho appena avuto un problema in cui stavo eseguendo il server usando Apache mod_ssl, ma un phpinfo () e un var_dump ($ _SERVER) hanno mostrato che PHP pensa ancora che io sia sulla porta 80.

Ecco la mia soluzione alternativa per chiunque abbia lo stesso problema ....

<VirtualHost *:443>
  SetEnv HTTPS on
  DocumentRoot /var/www/vhost/scratch/content
  ServerName scratch.example.com
</VirtualHost>

La linea degna di nota è la linea SetEnv. Con questo in atto e dopo un riavvio, dovresti avere la variabile d'ambiente HTTPS che hai sempre sognato

Facendo la mia funzione dalla lettura di tutti i post precedenti:

public static function isHttps()
{
    if (array_key_exists("HTTPS", $_SERVER) && 'on' === $_SERVER["HTTPS"]) {
        return true;
    }
    if (array_key_exists("SERVER_PORT", $_SERVER) && 443 === (int)$_SERVER["SERVER_PORT"]) {
        return true;
    }
    if (array_key_exists("HTTP_X_FORWARDED_SSL", $_SERVER) && 'on' === $_SERVER["HTTP_X_FORWARDED_SSL"]) {
        return true;
    }
    if (array_key_exists("HTTP_X_FORWARDED_PROTO", $_SERVER) && 'https' === $_SERVER["HTTP_X_FORWARDED_PROTO"]) {
        return true;
    }
    return false;
}

Se usi Apache puoi sempre contare

$_SERVER["REQUEST_SCHEME"]

per verificare lo schema dell'URL richiesto. Ma, come menzionato in altre risposte, è prudente verificare altri parametri prima di supporre che SSL sia realmente utilizzato.

La vera risposta: pronta per essere copiata e incollata in uno script [config]

/* configuration settings; X=edit may 10th '11 */
$pv_sslport=443; /* for it might be different, as also Gabriel Sosa stated */
$pv_serverport=80; /* X */
$pv_servername="mysite.com"; /* X */

/* X appended after correction by Michael Kopinsky */
if(!isset($_SERVER["SERVER_NAME"]) || !$_SERVER["SERVER_NAME"]) {
    if(!isset($_ENV["SERVER_NAME"])) {
        getenv("SERVER_NAME");
        // Set to env server_name
        $_SERVER["SERVER_NAME"]=$_ENV["SERVER_NAME"];
    }
}
if(!$_SERVER["SERVER_NAME"]) (
    /* X server name still empty? ... you might set $_SERVER["SERVER_NAME"]=$pv_servername; */
}

if(!isset($_SERVER["SERVER_PORT"]) || !$_SERVER["SERVER_PORT"]) {
    if(!isset($_ENV["SERVER_PORT"])) {
        getenv("SERVER_PORT");
        $_SERVER["SERVER_PORT"]=$_ENV["SERVER_PORT"];
    }
}
if(!$_SERVER["SERVER_PORT"]) (
    /* X server port still empty? ... you might set $_SERVER["SERVER_PORT"]=$pv_serverport; */
}

$pv_URIprotocol = isset($_SERVER["HTTPS"]) ? (($_SERVER["HTTPS"]==="on" || $_SERVER["HTTPS"]===1 || $_SERVER["SERVER_PORT"]===$pv_sslport) ? "https://" : "http://") :  (($_SERVER["SERVER_PORT"]===$pv_sslport) ? "https://" : "http://");

$pv_URIprotocolè ora corretto e pronto per essere utilizzato; esempio $site=$pv_URIprotocol.$_SERVER["SERVER_NAME"]. Naturalmente, la stringa potrebbe essere sostituita anche con TRUE e FALSE. PV sta per PortalPress Variable in quanto è un copia-incolla diretto che funzionerà sempre. Questo pezzo può essere utilizzato in uno script di produzione.

Non penso che l'aggiunta di una porta sia una buona idea, specialmente quando hai molti server con build diverse. che aggiunge solo un'altra cosa da ricordare di cambiare. guardando i documenti penso che l'ultima riga di kaiser sia abbastanza buona, in modo che:

if(!empty($_SERVER["HTTPS"]))
  if($_SERVER["HTTPS"]!=="off")
    return 1; //https
  else
    return 0; //http
else
  return 0; //http

sembra abbastanza perfetto.

L'unico metodo affidabile è quello descritto da Igor M.

$pv_URIprotocol = isset($_SERVER["HTTPS"]) ? (($_SERVER["HTTPS"]==="on" || $_SERVER["HTTPS"]===1 || $_SERVER["SERVER_PORT"]===$pv_sslport) ? "https://" : "http://") :  (($_SERVER["SERVER_PORT"]===$pv_sslport) ? "https://" : "http://");

Considera quanto segue: Stai usando nginx con fastcgi, per impostazione predefinita (debian, ubuntu) fastgi_params contiene direttiva:

fastcgi_param HTTPS $ https;

se NON stai usando SSL, viene tradotto come valore vuoto, non "off", non 0 e sei condannato.

http://unpec.blogspot.cz/2013/01/nette-nginx-php-fpm-redirect.html

Trovo che anche questi parametri siano accettabili e più probabilmente non hanno falsi positivi quando si cambia server Web.

1. $ _SERVER [ 'HTTPS_KEYSIZE']
2. $ _SERVER [ 'HTTPS_SECRETKEYSIZE']
3. $ _SERVER [ 'HTTPS_SERVER_ISSUER']

4. $ _SERVER [ 'HTTPS_SERVER_SUBJECT']

   if($_SERVER['HTTPS_KEYSIZE'] != NULL){/*do foobar*/}

Il modo più breve che sto usando:

$secure_connection = !empty($_SERVER['HTTPS']);

Se si utilizza https, allora $ secure_connection è true.

È possibile verificare $_SERVER['SERVER_PORT']come SSL normalmente viene eseguito sulla porta 443, ma questo non è infallibile.

Cosa ne pensi di questo?

if (isset($_SERVER['HTTPS']) && !empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off')
    $scheme = 'https';
else
    $scheme = 'http';

Sul mio server (Ubuntu 14.10, Apache 2.4, php 5.5) la variabile $_SERVER['HTTPS']non è impostata quando lo script php viene caricato tramite https. Non so cosa sia sbagliato. Ma le seguenti righe nel .htaccessfile risolvono questo problema:

RewriteEngine on

RewriteCond %{HTTPS} =on [NC] 
RewriteRule .* - [E=HTTPS:on,NE]

Ecco una funzione riutilizzabile che utilizzo da un po 'di tempo. HTH.

Nota: il valore di HTTPS_PORT (che è una costante personalizzata nel mio codice) può variare in base al tuo ambiente, ad esempio può essere 443 o 81.

/**
 * Determine if this is a secure HTTPS connection
 * 
 * @return  bool    True if it is a secure HTTPS connection, otherwise false.
 */
function isSSL()
{
    if (isset($_SERVER['HTTPS'])) {
        if ($_SERVER['HTTPS'] == 1) {
            return true;
        } elseif ($_SERVER['HTTPS'] == 'on') {
            return true;
        }
    } elseif ($_SERVER['SERVER_PORT'] == HTTPS_PORT) {
        return true;
    }

    return false;
}

solo per interesse, Chrome Canary al momento invia

HTTPS : 1

al server e, a seconda della configurazione del server, può significare che si ottiene quanto segue

HTTPS : 1, on

Questo ha rotto la nostra applicazione perché stavamo testando se acceso, cosa che ovviamente non lo è. Al momento, solo il cromo canarino sembra farlo, ma vale la pena notare che le cose del canarino generalmente atterrano nel cromo "normale" poco dopo.

Se si utilizza nginx come sistema di bilanciamento del carico, controllare $ _SERVER ['HTTP_HTTPS'] == 1 altri controlli falliranno per ssl.

$secure_connection = ((!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off') || (!empty($_SERVER['HTTP_HTTPS']) && $_SERVER['HTTP_HTTPS'] != 'off') || $_SERVER['REQUEST_SCHEME'] == 'https' || $_SERVER['SERVER_PORT'] == 443) ? true : false;

Il codice controlla tutto il possibile e funziona anche sul server Web IIS. Chrome dalla v44 non imposta l'intestazione HTTP: 1, quindi controllare che HTTP_HTTPS sia OK. Se questo codice non corrisponde a https significa che il tuo server web o server proxy non è configurato correttamente. Apache stesso imposta correttamente il flag HTTPS ma può esserci un problema quando si utilizza il proxy (ad esempio nginx). È necessario impostare alcune intestazioni nell'host virtuale nginx https

proxy_set_header   X-HTTPS 1;

e usa alcuni moduli Apache per impostare correttamente il flag HTTPS cercando X-HTTPS dal proxy. Cerca mod_fakessl, mod_rpaf, ecc.

Se si utilizza il bilanciamento del carico di Incapsula, è necessario utilizzare un IRule per generare un'intestazione personalizzata per il proprio server. Ho creato un'intestazione HTTP_X_FORWARDED_PROTO che è uguale a "http" se la porta è impostata su 80 e "https" se è uguale a 443.

Aggiungerei un filtro globale per garantire che tutto ciò che sto controllando sia corretto;

function isSSL() {

    $https = filter_input(INPUT_SERVER, 'HTTPS');
    $port = filter_input(INPUT_SERVER, 'SERVER_PORT');
    if ($https) {

        if ($https == 1) {
            return true;
        } elseif ($https == 'on') {
            return true;
        }
    } elseif ($port == '443') {
        return true;
    }

    return false;
}

Ho occasione di fare un ulteriore passo avanti e determinare se il sito a cui mi sto collegando è abilitato per SSL (un progetto chiede all'utente il proprio URL e dobbiamo verificare che abbiano installato il nostro pacchetto API su un sito http o https).

Ecco la funzione che uso - in pratica, basta chiamare l'URL tramite cURL per vedere se https funziona!

function hasSSL($url) 
{
    // take the URL down to the domain name
    $domain = parse_url($url, PHP_URL_HOST);
    $ch = curl_init('https://' . $domain);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'HEAD'); //its a  HEAD
    curl_setopt($ch, CURLOPT_NOBODY, true);          // no body
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);  // in case of redirects
    curl_setopt($ch, CURLOPT_VERBOSE, 0); //turn on if debugging
    curl_setopt($ch, CURLOPT_HEADER, 1);     //head only wanted
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);    // we dont want to wait forever
    curl_exec($ch);
    $header = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if ($header === 200) {
        return true;
    }
    return false;
}

Questo è il modo più affidabile che ho scoperto non solo per scoprire se stai usando https (come fa la domanda), ma se POTREBBE (o anche DOVREBBE) usare https.

NOTA: è possibile (anche se non proprio probabile ...) che un sito possa avere diverse pagine http e https (quindi se ti viene detto di usare http, forse non è necessario cambiare ..) La stragrande maggioranza dei siti sono gli stessi e probabilmente dovrebbero reindirizzare te stesso, ma questo controllo aggiuntivo ha il suo uso (certamente come ho detto, nel progetto in cui l'utente immette le informazioni sul sito e vuoi assicurarti dal lato server)

Ecco come trovo risolverlo

$https = !empty($_SERVER['HTTPS']) && strcasecmp($_SERVER['HTTPS'], 'on') === 0 ||
        !empty($_SERVER['HTTP_X_FORWARDED_PROTO']) &&
            strcasecmp($_SERVER['HTTP_X_FORWARDED_PROTO'], 'https') === 0;

return ($https) ? 'https://' : 'http://';

Ho usato il suggerimento principale qui e mi sono infastidito dalla "Notifica PHP" nei registri quando HTTPS non è stato impostato. Puoi evitarlo usando l' operatore a coalescenza nulla "??":

if( ($_SERVER['HTTPS'] ?? 'off') == 'off' ) {
    // redirect
}

(Nota: non disponibile prima di php v7)

Secondo il post di hobodave: "Impostato su un valore non vuoto se lo script è stato interrogato tramite il protocollo HTTPS."

if (!empty($_SERVER['HTTPS']))
{
    $secure_connection = true;
}