Como detectar do lado do servidor se os cookies estão desativados

Como posso detectar no servidor (lado do servidor) se os cookies do navegador estão desabilitados? É possível?

Explicação detalhada: Estou processando uma solicitação HTTP no servidor. Quero definir um cookie por meio do Set-Cookiecabeçalho. Preciso saber naquele momento se o cookie será definido pelo navegador do cliente ou minha solicitação para definir o cookie será ignorada.

Envie uma resposta de redirecionamento com o conjunto de cookies; ao processar o teste de URL redirecionado (especial) para o cookie - se houver, redirecione para o processamento normal, caso contrário, redirecione para um estado de erro.

Observe que isso só informa que o navegador permitiu a configuração do cookie, mas não por quanto tempo. Meu FF me permite forçar todos os cookies para o modo "sessão", a menos que o site seja especificamente adicionado a uma lista de exceções - esses cookies serão descartados quando o FF for encerrado, independentemente da expiração do servidor especificado. E este é o modo em que sempre executo o FF.

Você pode usar Javascript para fazer isso

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;
}

Código a ser executado:

alert(areCookiesEnabled());

Lembrar

Isso só funciona se o Javascript estiver habilitado!

Não acho que existam maneiras diretas de verificar. A melhor maneira é armazenar um valor no cookie e tentar lê-lo e decidir se os cookies estão habilitados ou não.

Uma maneira comum de verificar o suporte a cookies é por meio de um redirecionamento.

É uma boa ideia fazer isso apenas quando o usuário está tentando fazer algo que inicia uma sessão, como fazer login ou adicionar algo ao carrinho. Caso contrário, dependendo de como você lida com isso, você está potencialmente bloqueando o acesso a todo o seu site para usuários - ou bots - que não oferecem suporte a cookies.

Primeiro, o servidor verifica os dados de login normalmente - se os dados de login estiverem errados, o usuário recebe esse feedback normalmente. Se estiver certo, o servidor responde imediatamente com um cookie e redireciona para uma página que foi projetada para verificar esse cookie - que pode ser apenas o mesmo URL, mas com algum sinalizador adicionado à string de consulta. Se essa segunda página não receber o cookie, o usuário receberá uma mensagem informando que não pode fazer login porque os cookies estão desabilitados em seu navegador.

Se você já está seguindo o padrão Post-Redirect-Get para o seu formulário de login, então essa configuração e verificação do cookie não adiciona nenhuma solicitação adicional - o cookie pode ser definido durante o redirecionamento existente e verificado pelo destino que carrega após o redirecionamento.

Agora, por que eu só faço um teste de cookie após uma ação iniciada pelo usuário, exceto em cada carregamento de página. Já vi sites implementarem um teste de cookie em cada página, sem perceber que isso afetará coisas como mecanismos de pesquisa que tentam rastrear o site. Ou seja, se um usuário tem cookies habilitados, o cookie de teste é definido uma vez, de modo que ele só precisa sofrer um redirecionamento na primeira página que solicitar e, a partir daí, não haverá redirecionamentos. No entanto, para qualquer navegador ou outro agente de usuário, como um mecanismo de pesquisa, que não retorna cookies, cada página pode simplesmente resultar em um redirecionamento.

Outro método de verificação de suporte a cookies é com Javascript - dessa forma, nenhum redirecionamento é necessário - você pode escrever um cookie e lê-lo de volta virtualmente imediatamente para ver se ele foi armazenado e depois recuperado. A desvantagem disso é que ele roda em script no lado do cliente - ou seja, se você ainda deseja que a mensagem sobre se os cookies são suportados para retornar ao servidor, então você ainda tem que organizar isso - como em uma chamada Ajax.

Para meu próprio aplicativo, implemento alguma proteção para ataques 'Login CSRF', uma variante dos ataques CSRF, definindo um cookie contendo um token aleatório na tela de login antes que o usuário efetue login e verificando esse token quando o usuário envia seu login detalhes. Leia mais sobre o Login CSRF do Google. Um efeito colateral disso é que, no momento em que eles fazem login, posso verificar a existência desse cookie - um redirecionamento extra não é necessário.

Normalmente, você só precisa verificar o suporte para cookies depois que o usuário realizar alguma ação no site, como enviar um formulário de login, adicionar um item ao carrinho e assim por diante.

Para mim, atualmente, a verificação de suporte a cookies anda de mãos dadas com a prevenção de CSRF (Cross-Site Request Forgery).

Você provavelmente deveria ir a outro lugar para ler mais sobre CSRF , mas a ideia por trás disso é que outros sites podem enganar seus usuários para que enviem uma forma oculta de sua escolha para o seu próprio site. A maneira de contornar isso é definir um cookie quando o visualizador vê um formulário e definir um token correspondente como um elemento de formulário oculto e, em seguida, ao processar o formulário, verifique se o cookie e o elemento de formulário oculto foram definidos e correspondem um ao outro. Se for uma tentativa de ataque CSRF, o site não será capaz de fornecer o campo oculto para corresponder ao cookie do usuário, porque o cookie do usuário não será legível para eles sob a política de mesma origem.

Se um formulário é enviado sem cookie, mas contém um token de aparência válida, então você pode concluir que o usuário desativou os cookies e exibir uma mensagem indicando que o usuário deve habilitar os cookies e tentar novamente. A outra possibilidade, é claro, é que o usuário seja vítima de uma tentativa de ataque CSRF. Portanto, bloquear o usuário quando o cookie não corresponde também terá o efeito colateral de prevenir esse ataque.

Eu sempre usei isso:

navigator.cookieEnabled

De acordo com w3schools "A propriedade cookieEnabled é compatível com todos os principais navegadores.".

No entanto, isso funciona para mim quando estou usando formulários, onde posso instruir o navegador a enviar as informações adicionais.

Tente armazenar algo em um biscoito e depois leia. Se você não obtiver o que espera, os cookies provavelmente estão desativados.

verifique este código, ele irá ajudá-lo.

<?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());

A questão de saber se os cookies estão "habilitados" é muito booleana. Meu navegador (Opera) tem uma configuração de cookie por site. Além disso, essa configuração não é sim / não. A forma mais útil é, na verdade, "somente sessão", ignorando a data de expiração dos servidores. Se você testá-lo diretamente após a configuração, ele estará lá. Amanhã, não vai.

Além disso, como é uma configuração que você pode alterar, até mesmo testar se os cookies permanecem apenas informa sobre a configuração durante o teste . Eu posso ter decidido aceitar aquele cookie manualmente. Se eu continuar recebendo spam, posso (e às vezes irei) apenas desligar os cookies desse site.

Se você deseja apenas verificar se os cookies de sessão (cookies que existem durante o tempo de vida da sessão) estão habilitados, defina seu modo de sessão como AutoDetect em seu arquivo web.config, então a estrutura Asp.Net gravará um cookie no navegador do cliente chamado AspxAutoDetectCookieSupport . Você pode então procurar por esse cookie na coleção Request.Cookies para verificar se os cookies de sessão estão habilitados no cliente.

Por exemplo, em seu conjunto de arquivos web.config:

<sessionState cookieless="AutoDetect" />

Em seguida, verifique se os cookies estão habilitados no cliente com:

if (Request.Cookies["AspxAutoDetectCookieSupport"] != null)  { ... }

Sidenote: Por padrão, é definido como UseDeviceProfile, que tentará gravar cookies no cliente, desde que o cliente os suporte , mesmo se os cookies estiverem desativados. Acho um pouco estranho que esta seja a opção padrão, pois parece meio inútil - as sessões não funcionam com cookies desabilitados no navegador do cliente com ele definido como UseDeviceProfile e se você oferece suporte ao modo cookieless para clientes que não oferecem suporte a cookies , então por que não usar AutoDetect e suportar o modo cookieless para clientes que os desativaram ...

Estou usando uma versão muito mais simplificada da resposta de "balexandre" acima. Ele tenta definir e ler um cookie de sessão com o único propósito de determinar se os cookies estão habilitados. E sim, isso requer que o JavaScript também esteja ativado. Portanto, você pode querer uma etiqueta lá se quiser.

<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 - Servidor - Verificação de Cookie Redirecionar Middleware - Express Session / Cookie Parser

Dependências

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()
}

A cookieEnabledpropriedade retorna um valor booleano que especifica se os cookies estão ou não habilitados no navegador

<script>
if (navigator.cookieEnabled) {
    // Cookies are enabled
}
else {
    // Cookies are disabled
}
</script>

Use navigator.CookieEnabled para cookies habilitados (retornará verdadeiro ou falso) e a tag Html noscript. Já agora, navigator.cookieEnabled é javascript, por isso não o escreva como HTML

<?php   session_start();
if(SID!=null){
  echo "Please enable cookie";
}
?>