Come posso rilevare sul server (lato server) se i cookie nel browser sono disabilitati? È possibile?
Spiegazione dettagliata: sto elaborando una richiesta HTTP sul server. Voglio impostare un cookie tramite l' Set-Cookieintestazione. In quel momento ho bisogno di sapere se il cookie verrà impostato dal browser del client o la mia richiesta di impostare il cookie verrà ignorata.
Risposte:
Invia una risposta di reindirizzamento con il set di cookie; durante l'elaborazione del test URL (speciale) reindirizzato per il cookie: se è presente, reindirizza alla normale elaborazione, altrimenti reindirizza a uno stato di errore.
Tieni presente che questo può solo dirti che il browser ha consentito l'impostazione del cookie, ma non per quanto tempo. Il mio FF mi consente di forzare tutti i cookie in modalità "sessione", a meno che il sito non venga aggiunto in modo specifico a un elenco di eccezioni - tali cookie verranno eliminati quando FF si spegne indipendentemente dalla scadenza specificata dal server. E questa è la modalità in cui eseguo sempre FF.
Puoi usare Javascript per farlo
Biblioteca:
function createCookie(name, value, days) {
var expires;
if (days) {
var date = new Date();
date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
expires = "; expires=" + date.toGMTString();
}
else expires = "";
document.cookie = name + "=" + value + expires + "; path=/";
}
function readCookie(name) {
var nameEQ = name + "=";
var ca = document.cookie.split(';');
for (var i = 0; i < ca.length; i++) {
var c = ca[i];
while (c.charAt(0) == ' ') c = c.substring(1, c.length);
if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
}
return null;
}
function eraseCookie(name) {
createCookie(name, "", -1);
}
function areCookiesEnabled() {
var r = false;
createCookie("testing", "Hello", 1);
if (readCookie("testing") != null) {
r = true;
eraseCookie("testing");
}
return r;
}Codice da eseguire:
alert(areCookiesEnabled());Ricorda
Funziona solo se Javascript è abilitato!
Un modo comune per verificare il supporto dei cookie è tramite un reindirizzamento.
È una buona idea farlo solo quando l'utente sta cercando di fare qualcosa che avvia una sessione, come accedere o aggiungere qualcosa al carrello. Altrimenti, a seconda di come lo gestisci, stai potenzialmente bloccando l'accesso al tuo intero sito per gli utenti - o bot - che non supportano i cookie.
Innanzitutto, il server controlla i dati di accesso normalmente: se i dati di accesso sono errati, l'utente riceve quel feedback normalmente. Se è corretto, il server risponde immediatamente con un cookie e un reindirizzamento a una pagina progettata per verificare la presenza di quel cookie, che potrebbe essere lo stesso URL ma con qualche flag aggiunto alla stringa di query. Se la seconda pagina non riceve il cookie, l'utente riceve un messaggio che informa che non può accedere perché i cookie sono disabilitati sul proprio browser.
Se stai già seguendo lo schema Post-Reindirizzamento-Ottieni per il tuo modulo di accesso, questa impostazione e il controllo del cookie non aggiungono ulteriori richieste: il cookie può essere impostato durante il reindirizzamento esistente e controllato dalla destinazione caricata dopo il reindirizzamento.
Ora, perché eseguo un test dei cookie solo dopo un'azione avviata dall'utente diversa dal caricamento di ogni pagina. Ho visto siti implementare un test dei cookie su ogni singola pagina, senza rendersi conto che questo avrà effetti su cose come i motori di ricerca che tentano di eseguire la scansione del sito. Cioè, se un utente ha i cookie abilitati, il cookie di prova viene impostato una volta, quindi deve solo sopportare un reindirizzamento sulla prima pagina richiesta e da quel momento in poi non ci sono reindirizzamenti. Tuttavia, per qualsiasi browser o altro user-agent, come un motore di ricerca, che non restituisce cookie, ogni singola pagina potrebbe semplicemente risultare in un reindirizzamento.
Un altro metodo per verificare il supporto dei cookie è con Javascript: in questo modo non è necessario alcun reindirizzamento, puoi scrivere un cookie e leggerlo di nuovo praticamente immediatamente per vedere se è stato memorizzato e quindi recuperato. Lo svantaggio di questo è che viene eseguito in script su lato client, cioè se vuoi ancora che il messaggio se i cookie siano supportati per tornare al server, devi comunque organizzarlo, come con una chiamata Ajax.
Per la mia applicazione, implemento una certa protezione per gli attacchi "Login CSRF", una variante degli attacchi CSRF, impostando un cookie contenente un token casuale nella schermata di accesso prima che l'utente effettui l'accesso e controllando quel token quando l'utente invia il proprio login dettagli. Ulteriori informazioni su Login CSRF da Google. Un effetto collaterale di questo è che nel momento in cui effettuano l'accesso, posso verificare l'esistenza di quel cookie: non è necessario un reindirizzamento aggiuntivo.
Di solito, potrebbe essere necessario verificare il supporto dei cookie solo dopo che l'utente ha intrapreso un'azione sul sito, come l'invio di un modulo di accesso, l'aggiunta di un articolo al carrello e così via.
Per me attualmente, la verifica del supporto dei cookie va di pari passo con la prevenzione di CSRF (Cross-Site Request Forgery).
Probabilmente dovresti andare altrove per saperne di più su CSRF , ma l'idea alla base è che altri siti potrebbero indurre i tuoi utenti a inviare un modulo nascosto di loro scelta al tuo sito. Il modo per aggirare questo è impostare un cookie quando il visualizzatore vede un modulo e impostare un token corrispondente come elemento del modulo nascosto, quindi durante l'elaborazione del modulo, verificare che sia il cookie che l'elemento del modulo nascosto siano stati impostati e corrispondano tra loro. Se si tratta di un tentativo di attacco CSRF, il sito non sarà in grado di fornire il campo nascosto in modo che corrisponda al cookie dell'utente, perché il cookie dell'utente non sarà leggibile per loro secondo la policy della stessa origine.
Se viene inviato un modulo senza cookie, ma contiene un token dall'aspetto valido, è possibile concludere da ciò che l'utente ha i cookie disabilitati e visualizzare un messaggio che indica che l'utente deve abilitare i cookie e riprovare. L'altra possibilità, ovviamente, è che l'utente sia vittima di un tentativo di attacco CSRF. Quindi bloccare l'utente quando il cookie non corrisponde avrà anche l'effetto collaterale di prevenire quell'attacco.
Ho sempre usato questo:
navigator.cookieEnabled
Secondo w3schools "La proprietà cookieEnabled è supportata in tutti i principali browser.".
Tuttavia, questo funziona per me quando utilizzo i moduli, dove posso istruire il browser per inviare le informazioni aggiuntive.
Prova a memorizzare qualcosa in un cookie e poi leggilo. Se non ottieni ciò che ti aspetti, probabilmente i cookie sono disabilitati.
controlla questo codice, ti aiuterà.
<?php
session_start();
function visitor_is_enable_cookie() {
$cn = 'cookie_is_enabled';
if (isset($_COOKIE[$cn]))
return true;
elseif (isset($_SESSION[$cn]) && $_SESSION[$cn] === false)
return false;
// saving cookie ... and after it we have to redirect to get this
setcookie($cn, '1');
// redirect to get the cookie
if(!isset($_GET['nocookie']))
header("location: ".$_SERVER['REQUEST_URI'].'?nocookie') ;
// cookie isn't availble
$_SESSION[$cn] = false;
return false;
}
var_dump(visitor_is_enable_cookie());
La domanda se i cookie sono "abilitati" è troppo booleana. Il mio browser (Opera) ha un'impostazione dei cookie per sito. Inoltre, tale impostazione non è sì / no. La forma più utile è infatti "solo sessione", ignorando la data di scadenza dei server. Se lo provi subito dopo l'impostazione, sarà lì. Domani non lo farà.
Inoltre, poiché è un'impostazione che puoi modificare, anche testare se i cookie rimangono ti dice solo dell'impostazione quando hai testato . Potrei aver deciso di accettare quel cookie, manualmente. Se continuo a ricevere spam, posso (ea volte, lo farò) semplicemente disattivare i cookie per quel sito.
Se desideri solo controllare se i cookie di sessione (cookie che esistono per la durata della sessione) sono abilitati, imposta la modalità di sessione su AutoDetect nel tuo file web.config, quindi il framework Asp.Net scriverà un cookie nel browser del client chiamato AspxAutoDetectCookieSupport . È quindi possibile cercare questo cookie nella raccolta Request.Cookies per verificare se i cookie di sessione sono abilitati sul client.
Ad esempio, nel set di file web.config:
<sessionState cookieless="AutoDetect" />
Quindi controlla se i cookie sono abilitati sul client con:
if (Request.Cookies["AspxAutoDetectCookieSupport"] != null) { ... }
Nota a margine: per impostazione predefinita, è impostato su UseDeviceProfile, che tenterà di scrivere i cookie sul client finché il client li supporta , anche se i cookie sono disabilitati. Trovo un po 'strano che questa sia l'opzione predefinita in quanto sembra un po' inutile: le sessioni non funzioneranno con i cookie disabilitati nel browser client con esso impostato su UseDeviceProfile e se supporti la modalità senza cookie per i client che non supportano i cookie , allora perché non utilizzare AutoDetect e supportare la modalità senza cookie per i client che li hanno disabilitati ...
Sto usando una versione molto più semplificata della risposta di "balexandre" sopra. Tenta di impostare e leggere un cookie di sessione al solo scopo di determinare se i cookie sono abilitati. E sì, questo richiede che anche JavaScript sia abilitato. Quindi potresti volere un tag lì dentro se ti interessa averne uno.
<script>
// Cookie detection
document.cookie = "testing=cookies_enabled; path=/";
if(document.cookie.indexOf("testing=cookies_enabled") < 0)
{
// however you want to handle if cookies are disabled
alert("Cookies disabled");
}
</script>
<noscript>
<!-- However you like handling your no JavaScript message -->
<h1>This site requires JavaScript.</h1>
</noscript>
NodeJS - Lato server - Middleware di reindirizzamento controllo cookie - Sessione Express / Parser cookie
Dipendenze
var express = require('express'),
cookieParser = require('cookie-parser'),
expressSession = require('express-session')
Middleware
return (req, res, next) => {
if(req.query.cookie && req.cookies.cookies_enabled)
return res.redirect('https://yourdomain.io' + req.path)
if(typeof(req.cookies.cookies_enabled) === 'undefined' && typeof(req.query.cookie) === 'undefined') {
return res.cookie('cookies_enabled', true, {
path: '/',
domain: '.yourdomain.io',
maxAge: 900000,
httpOnly: true,
secure: process.env.NODE_ENV ? true : false
}).redirect(req.url + '?cookie=1')
}
if(typeof(req.cookies.cookies_enabled) === 'undefined') {
var target_page = 'https://yourdomain.io' + (req.url ? req.url : '')
res.send('You must enable cookies to view this site.<br/>Once enabled, click <a href="' + target_page + '">here</a>.')
res.end()
return
}
next()
}
La cookieEnabledproprietà restituisce un valore booleano che specifica se i cookie sono abilitati o meno nel browser
<script>
if (navigator.cookieEnabled) {
// Cookies are enabled
}
else {
// Cookies are disabled
}
</script>
Usa navigator.CookieEnabled per i cookie abilitati (restituirà true o false) e il tag Html noscript. Tra l'altro navigator.cookieEnabled è javascript, quindi non digitarlo come HTML
<?php session_start();
if(SID!=null){
echo "Please enable cookie";
}
?>