segunda-feira, 7 de junho de 2010

Tipo ENUM no MySQL e no PostgreSQL

Tempos atrás eu publiquei aqui, sobre os tipos ENUM e SET no MySQL, porém as respostas dos leitores deixaram claro que eu não havia explicado o assunto direito. E relendo o texto, realmente assumo que ficou péssimo. Não consegui passar o conceito, quanto menos a aplicabilidade desses recursos.

Então aqui cabe a redenção. Vamos ao tipo ENUM. Ele não é um tipo definido no padrão SQL, e sim implementações proprietárias, encontrado nos bancos de dados mais comuns. Assim seu comportamento, espaço em disco e queries que podem ser usadas diferem ligeiramente entre suas implementações, mas a idéia por trás do tipo ENUM é comum a todos.

As vantagens do uso do tipo ENUM são:
  • ganho de performance
  • segurança dos dados

As desvantagens são:
  • limites de uso (a alteração requer a reestruturação da tabela)
  • a não portabilidade devido as diferenças de implementação

A principal característica do tipo ENUM é permitir a criação de uma lista enumerada, sendo cada registro um par index-value. A idéia é bem simples mesmo, mas extremamente eficaz e poderosa. O uso do tipo ENUM deve ser feito em parâmetros onde há pouca ou nenhuma alteração durante a existência da aplicação - por exemplo, sexo, ou um sistema de rating com valores fixos de entrada.

CREATE TABLE 'myPics' (
'id' INT NOT NULL AUTO_INCREMENT ,
'url' VARCHAR( 255 ) NOT NULL ,
'rate' ENUM('bad', 'good', 'excellent') NULL DEFAULT 'good',
PRIMARY KEY ('id') ,
INDEX ('url')
) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_bin;

Na tabela de exemplo acima, criamos o campo rate, que deve armazenar a classificação da foto. Os possíveis valores são: NULL, 'bad', 'good' e 'excellent'. Ou seja você tem valores pré-definidos para o input de dados, e a cada um é atribuído um índice na ordem em que foram declarados. Os possíveis valores para o nosso campo são:
valor índice
NULL NULL
'' 0
bad 1
good 2
excellent 3

Na hora da query uma possível construção seria:

SELECT name, rate FROM myPics WHERE rate >= 'good';

Isso demonstra a utilidade do tipo ENUM. Ao invés de criar uma tabela auxiliar e atribuir valores a ela, podemos reduzir essa complexidade fazendo uso do tipo ENUM em nossa arquitetura. Ah sim, qualquer função que demande tipos numéricos (SUM(), AVG(), MIN(), MAX(), COUNT()....) podem ser usadas em cima dos campos ENUM. Nesse caso, os valores são primeiro transformados no seu índice numérico.

E vale mencionar mais uma vez que o índice atribuído depende da ordem da declaração dos possíveis valores. Se você declarar ENUM ('bom', 'ruim'), 'bom' terá um valor menor do que 'ruim', e se declarar ENUM ('ruim', 'bom'), 'ruim' terá um valor menor do que 'bom'.

No Postgresql o uso do tipo enum é ligeiramente diferente. O trecho a seguir ilustra o mesmo exemplo anterior, só no que postgre.

CREATE TYPE rating AS ENUM ('bad', 'good', 'excellent');
CREATE TABLE myPics (
id serial,
url varchar(255),
rate rating
);

É necessário criar um tipo de dado com nome próprio do tipo ENUM, e depois atribuí-lo à coluna. Na hora de utilizar, nos beneficiamos dos mesmos recursos de construção.

Agora sobre o tipo SET. O tipo SET só existe no MySQL. E uma possível aplicação para ilustrar sua utilidade seria um sistema de tags, implementado de forma nativa na tabela.

Considere a seguinte tabela:

CREATE TABLE 'myPics' (
'id' INT NOT NULL AUTO_INCREMENT ,
'url' VARCHAR( 255 ) NOT NULL ,
'rate' ENUM('bad', 'good', 'excellent') NULL,
'tags' SET('outdoor', 'studio', 'stock', 'fruits', 'nature', 'close-up', 'people') NULL
PRIMARY KEY ('id') ,
INDEX ('url')
) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_bin

Nela, podemos atribuir valores como:

INSERT INTO myPics (id, url, rate, tags) VALUES (NULL, 'xxx', 'good', 'people, close-up'), (NULL, 'yyy', 'excellent', 'fruits, nature, close-up');

Ou seja declarando as tags direto no insert. Na hora de fazer o SELECT, contamos com mais uma função nativa do MySQL bem útil, a FIND_IN_SET:

SELECT * from myPics WHERE FIND_IN_SET('nature', tags) > 0 AND FIND_IN_SET('close-up', tags) > 0;

Isso vai trazer todos os registros cujo campo tags contenha os valores 'nature' e 'close-up'.

Bom, acho que agora o conceito e a aplicação dos tipos ENUM e SET está agora mais clara e mais útil.

-----------
keepReading

quarta-feira, 2 de junho de 2010

Open Source e o bug tracking

Fala pessoal,

nem preciso dizer que sou um entusiasta do movimento do software livre. Embora existam algumas divergências e tecnicismos sobre as definições e terminologias sobre o que é open source, o que é livre e etc... uma coisa é certa: o espírito de ajuda mútua em criar algo que beneficie quem usa os softwares.

E isso é feito de várias formas. Uma das bases desse mundo é a relatação de defeitos encontrados. É algo simples, eficaz e que muitas empresas privadas de desenvolvimento de software adotaram. Você está usando o programa e de repente ele trava, ou dá uma mensagem de erro. Bem, você então relata este erro aos desenvolvedores, assim eles podem investigar o que aconteceu, e trabalhar para a melhoria do produto. Desta forma todo mundo ganha.

Mas se tem algo que me deixa puto da vida é quando eu tenho um bug para reportar, depois de muita googlada, pesquisa, etc, e o serviço de bug tracking não responde de acordo, ou torna a tarefa de reportar um bug mis complicada do que deveria. É o que está acontecendo comigo neste exato momento.

Eu concordo que se deva oferecer ferramentas que automatizem a tarefa de juntar informações necessárias, ainda mais com usuários menos experientes, assim eles podem dar uma contribuição de qualidade, mesmo sem enteder muito do sistema.

Mas no caso eu poderia reportar um bug, com muita informação, e simplesmente não consigo. Processo complicado demais, lento demais, e instável demais (timeouts, internal errors..).

Fico chateado de ver isso, sinceramente. Pois é um gargalo a mais na hora de melhorar a qualidade do produto. E assim a comunidade se enfraquece.

----------- keepReading

A Verdade sobre Sessões

Estou iniciando uma série aqui no blog. Vou traduzir artigos e posts renomados sobre programação e desenvolvimento.

Para a estréia, escolhi um artigo altamente esclarecedor do Chris Shiflett, The Truth About Sessions, que explica em detalhes como as seções do PHP funcionam. Este artigo está originalmente sob licensa Creative Commons, bem como esta tradução. Vamos lá.

Introdução

Praticamente toda aplicação em PHP usa sessões. Este artigo dá uma olhada detalhada na implementação de um mecanismo seguro de gerência de sessões em PHP. Seguindo uma introdução básica de HTTP, o desafio de manter estado, e a operação básica de Cookies, eu vou explicar através de métodos simples e efetivos que podem ser usados para aumentar a segurança e a confiabilidade de suas aplicações PHP com estado.

A falta de estado

HTTP é um protocolo sem estado. Isso porque não há nada dentro do protocolo que requisite que o browser identifique a si mesmo em cada requisição, e também não há nenhuma conexão estabelecida entre o browser e o servidor que persista entre uma página e a próxima. Quando um usuário visita um site, o browser do usuário envia uma requisição HTTP ao servidor, que por sua vez envia uma resposta HTTP de volta. Essa é a extensão da comunicação, e representa uma transação HTTP completa.

Como a web se baseia em comunicações HTTP, manter o estado em aplicações web pode ser particularmente desafiador para desenvolvedores. Cookies são uma extensão do HTTP que foram introduzidos para ajudar a providenciar transações HTTP com estado, mas preocupações com privacidade levaram muitos usuários a desabilitar o suporte a cookies. Informações sobre estado podem ser passadas na URL, mas a divulgação acidental dessa informação mostra sérios riscos de segurança. De fato, a própria natureza de manter estado requer que o cliente identifique a si mesmo, assim a nossa consciência sobre segurança nos diz que nós nunca devemos confiar nas informações enviadas pelos clientes.

Apesar de tudo isso, existem soluções elegantes para o problema de manter o estado. Não existe solução perfeita, é claro, nem existe uma única solução que satisfaça as necessidades de todos. Este artigo introduz algumas técnicas que podem confiavelmente prover o manutenção do estado, bem como se proteger contra técnicas de invasão através de ataques de sessão, como o roubo de sessão. Mais abaixo, você vai aprender como os cookies realmente funcionam, o que as seções PHP fazem, e o que é preciso para roubar uma sessão.

Visão geral sobre HTTP

Para apreciar o desafio de manter o estado bem como escolher a melhor solução às suas necessidades, é importante entender um pouco sobre a arquitetura de web por trás disso tudo, o HyperText Transfer Protocol (HTTP).

Uma visita a http://exemplo.org/ requer que o navegador envie uma requisição HTTP para exemplo.org na porta 80. A sintaze dessa requisição é algo mais ou menos assim:
GET / HTTP/1.1
Host: exemplo.org

A primeira linha é chamada linha de requisição, e o segundo parâmetro (uma barra neste exemplo) é o caminho do recurso solicitado. Uma barra representa a raíz do documento; o servidor web transforma a raíz do documento para um caminmho específico no sistema de arquivos. Usuários do Apache podem estar acostumados a configurar este caminho com a diretiva DocumentRoot. Se http://www.exemplo.org/caminho/para/script.php é solicitado, o caminho para o recurso solicitado na requisição é /caminho/para/script.php. Se a raíz do documento está definida para ser /usr/local/apache/htdocs, o caminho completo para o recurso que o servidor irá usar é /usr/local/apache/htdocs/caminho/para/script.php

Existem muitas tecnologias como mod_rewrite que oferecem mais flexibilidade quando estão mapeando uma URL para um recurso específico

A segunda linha ilustra a sintaxe de de um cabeçalho HTTP. O cabeçalho neste exemplo é Host, e identifica o nome do domínio do servidor onde o browser pretende requisitar um recurso. Este cabeçalho é requerido pelo HTTP/1.1 e ajuda a prover suporte a mecanismos de virtual hosting, múltiplos domínios sendo servidor por um único endereço IP público. Existem muitos outros cabeçalhos opcionais que podem ser incluídos numa requisição, e você pode estar familiarizado em fazer referência a alguns deles no seu código PHP; exemplos incluem $_SERVER['HTTP_REFERER'] que se refere ao cabeçalho Referer e $_SERVER['HTTP_USER_AGENT'] que se refere ao cabeçalho User-Agent.

Uma nota particular desta requisição é que não há nada dentro dela que possa ser usado para identificar unicamente para identificar o cliente. Alguns desenvolvedores recorrem a informações obtidas do do TCP/IP (como o endereço IP) para identificação única, mas essa abordagem tem muitos problemas. Mais notavelmente, um único usuário pode potencialmente usar diferentes endereços IP para cada requisição (como no caso de grandes provedores de internet como AOL), e vários usuários podem usar o mesmo endereço IP (como no caso de laboratórios de computador usando um proxy HTTP). Estas situações podem fazer com que um único usuário aparente ser vários, ou muitos usuários aparentar ser apenas um. Para qualquer método de prover estado seguro e confiável, apenas informações obtidas do HTTP podem ser usadas.

O primeiro passo em manter o estado da aplicação é de alguma forma identificar unicamente cada cliente. Visto que a única fonte confiável de informações que podem ser usadas para a identificação deve vir da requisição HTTP, é necessário algo esteja dentro da requisição que possa ser usado para identificação única. Existem algumas poucas formas de se fazer isso, mas a solução desenvolvida para resolver este problema em particular é o cookie.

Cookies

A constatação de que deve haver um método único de identificação dos clientes resultou nos cookies, uma solução bastante criativa. Cookies são mais fáceis de entender se você considerá-los uma extensão do protocolo HTTP, o que é precisamente o que eles são. Os cookies estão definidos pelo RFC 2965, embora a especificação original escrita pela Netscape se aproxime mais do suporte à indústria.

Existem dois cabeçalhos HTTP que são necessários para se implementar os cookies, Set-Cookie e Cookie. O servidor web inclui o cabeçalho Set-Cookie em resposta a uma requisição para que o browser inclua este cookie em futuras requisições. Um navegador compatível que está com os cookies ativados inclui o cabeçalho Cookie em todas as requisições subsequentes (que satisfaçam as condições definidas pelo cabeçalho Set-Cookie) até que o cookie expire. Um scenario típico consiste de duas transações (quatro mensagens HTTP):

  1. O cliente envia uma requisição HTTP
  2. O servidor envia uma resposta HTTP que inclui o cabeçalho Set-Cookie
  3. O cliente envia uma requisição com o cabeçalho Cookie
  4. O servidoe envia uma resposta HTTP

Esta troca está ilustrada na figura 1:

Figura 1

A adição do cabeçalho Cookie na segunda requisição do cliente providencia a informação que o servidor pode usar para identificar unicamente o cliente. Também é neste ponto que o servidor (ou um script PHP no lado do servidor) pode determinar se o usuário tem cookies habilitados. Embora o usuário possa escolher desabilitar os cookies, é razoavelmente seguro assumir que as preferências do usuário não vão mudar enquanto ele interage com sua aplicação. Este fato pode provar ser muito útil, como em breve será demonstrado.

Dados GET e POST

Existem dois métodos adicionais que um cliente pode usar para enviar dados ao servidor, e estes métodos são anteriores aos cookies. Um cliente pode incluir informação na URL requisitada, tanto na query string ou como parte do caminho. Como um exemplo de query string, considere a seguinte requisição:
GET /index.php?foo=bar HTTP/1.1
Host: example.org
O script receptor, index.php, pode referenciar $_GET['foo'] para fazer referência ao valor bar. Por isso, muitos desenvolvedores PHP se referenciam a estes dados como dados GET (outros algumas vezes chamam de dados query string, ou variáveis de URL). Um ponto de confusão comum, é que os dados GET podem existir mesmo numa requisição POST, porque eles são simplesmente parte da URL e não dependem do método de requisição.

Uma outra forma que os os clientes pode usar para enviar dados é utilizando a porção conteúdo da requisição HTTP. Esta técnica requer que o método de requisição seja o POST, e um exemplo de tal requisição é como o seguinte:
POST /index.php HTTP/1.1
Host: example.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 7

foo=bar

Neste caso, o script receptor, index.php, pode se referenciar a $_POST['foo'] para fazer referência ao valor bar. Os desenvolvedores PHP se referem tipicamente a estes dados como dados POST, e é assim que um browser passa os dados submetidos através de um formulário cuja propriedade method é o POST.

Um request pode potencialmente ter os dois tipos de dado, desta forma:
POST /index.php?myget=foo HTTP/1.1
Host: example.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 11

mypost=bar

Estes dois métodos adicionais de enviar dados podem prover substitutos aos cookies. Diferente dos cookies, GET e POST não são opcionais, então estes métodos são mais confiáveis. Considere um identificador único chamado PHPSESSID incluído na URL requerida como segue:
GET /index.php?PHPSESSID=12345 HTTP/1.1
Host: example.org

Isto cumpre com o mesmo objetivo do cabeçalho Cookies, porque o cliente identifica a si mesmo, mas é muito menos automático para o desenvolvedor. Uma vez que o cookie está definido, é responsabilidade do browser enviá-lo nas requisições subsequentes. Para propagar o identificador único através das URLs, o desenvolvedor precisa garantir que todos os links, formulários, e similares a ter a query string apropriada (o PHP pode ajudar nisso se você habilitar a opção session.enable_trans_sid). Em adição, dados GET são mostrados na URL e são muitos mais expostos do que cookies. De fato, usuários desavisados podem salvar tais URLs nos favoritos, enviar para um amigo, ou um número qualquer de outras coisas que podem acidentalmente revelar sua identificação única.

Embora os dados POST sejam menos suscetíveis a serem expostos, propagar o identificador único como uma variável POST requer que todas as requisições ao servidor sejam também POST. Esta não é uma opção conveniente, ainda que o design da sua aplicação possa fazer isso viável.

Gerenciamento de sessões

Até agora, eu discuti sobre estado. Este é um detalhe de nível baixo o bastante que envolve o a associação de uma transação HTTP com outra. O recurso mais útil com o qual provavelmente você esteja familiarizado seja o gerenciamento de sessões. Gerenciamento de sessões não se baseia apenas na habilidade de manter o estado, mas também requer que você mantenha dados unicamente associados com cada usuário. Este dados costumam ser chamados de dados de seção, porque são associados com uma seção específica do usuário. Se você usa o mecanismo nativo do PHP para gerenciamento de sessões, os dados de sessão são mantidos para você (em /tmp por padrão) e disponíveis através do vetor superglobal $_SESSION. Um exemplo simples do uso de sessões envolve a persistência dos dados de sessão entre uma página e a próxima. A lista 1, start.php, demonstra como isso pode ser feito:

Lista 1:
<?php

session_start();
$_SESSION['foo'] = 'bar';

?>

<a href="continue.php">continue.php</a>

Assumindo que o usuário clica no link dentro de tart.php, o script receptor (continue.php) poderá acessar a mesma variável de sessão, $_SESSION['foo']. Isto é mostrado na lista 2.

Lista 2:
<?php
session_start();
echo $_SESSION['foo']; /* bar */
?>

Sérios riscos existem quando você escreve o código desta forma sem entender o que o PHP faz por você. Sem este conhecimento, você poderá achar difícil depurar erros de sessões, ou prover um nível razoável de segurança.

Personificação

É um equívoco comum acreditar que o mecanismo de gerenciamento de sessões nativo do PHP provê defesas contra os ataques baseados em sessões. Ao contrário, o PHP simplesmente provê um mecanismo conveniente. É responsabilidade do desenvolvedor prover as defesas de segurança apropriadas. Como mencionado antes, não existe solução perfeita, nem uma melhor solução apropriada que se aplique a todos.

Para explicar o risco da personificação, considere a seguinte série de eventos:

  1. Pessoa inocente visita http://www.exemplo.org/ e faz login
  2. exemplo.org define um cookie, PHPSESSID=12345
  3. Pessoa maliciosa visita http://www.exemplo.org/ e apresenta um cookie, PHPSESSID=12345
  4. exemplo.org confunde pessoa maliciosa com pessoa inocente

Estes eventos estão ilustrados na figura 2.

Figura 2


É claro, este cenário assume que a pessoa maliciosa de alguma forma descobre ou adivinha a PHPSESSID válida que pertence a pessoa inocente. Enquanto isto pode parecer improvável, é um exemplo de segurança sobre obscuridade e não é algo sobre o qual devemos nos basear. Obscuridade não é uma coisa ruim, é claro, e pode ajudar, mas precisa ser algo mais substancial no lugar que ofereça proteção confiável contra tais ataques.

Prevenindo a personificação

Existem muitas técnicas que podem ser usadas para complicar a personificação ou outros ataques baseados em sessões. A aproximação geral, é fazer as coisas tão convenientes quanto for possível para legitimar seus usuários e tão complicadas quanto possível para os atacantes. Este é um balanço desafiante a ser atingido, e o balanço perfeito depende muito do design da aplicação. Assim, você é o melhor juiz no fim das contas.

A requisição HTTP/1.1 válida mais simples consiste de uma linha de requisição e o cabeçalho Host.

GET / HTTP/1.1
Host: example.org

Se o cliente estiver passando o identificador único de sessão PHPSESSID, este pode ser passado no cabeçalho Cookie como a seguir:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345

Alternativamente, o cliente pode passar o identificador único de sessão na URL requisitada

GET /?PHPSESSID=12345 HTTP/1.1
Host: example.org

O identificador de sessão também pode ser incluído como dados POST, mas isto tipicamente envolve uma experiência de usuário menos amigável e é a abordagem menos popular.

Porque a informação obtida do TCP/IP não pode ser confiavelmente usada para ajudar a fortalecer a segurança do mecanismo, parece que há pouco o que um desenvolvedor pode fazer para complicar a personificação. Apesar de tudo, a única coisa que um atacante precisa fazer é enviar o mesmo identificador único que um usuário legítimo enviaria para personificar aquele usuário e roubar a sessão. Assim, parece que a única proteção é manter o identificador de sessão oculto ou fazer com que ele seja mais difícil de adivinhar (preferencialmente ambos).

O PHP gera um identificador de sessão randômico, que é praticamente impossível de adivinhar, então esta preocupação já está mitigada. Prevenir um atacante de descobrir um identificador válido de sessão é muito mais difícil, porque muito dessa responsabilidade está fora do domínio onde o desenvolvedor tem controle.

Existem muitas situações que podem resultar na exposição do identificador de sessão do usuário. Dados GET podem ser erroneamente guardados em cache, observados por um estranho, guardado nos favoritos, ou enviados por email. Cookies provêm um mecanismo mais safo, mas usuários podem desabilitar o suporte a cookies, descartando a possibilidade de usá-los, e vulnerabilidades passadas no Internet Explorer foram conhecidas por revelar cookies a sites não autorizados.

Assim, um desenvolvedor pode estar bem certo de que o identificador de sessão não possa ser adivinhado, mas a possibilidade de que ele seja revelado a um atacante é mais provável, independente do método utilizado para propagá-lo. Algo adicional é necessário para ajudar a prevenir a personificação.

Na prática, uma típica requisição HTTP inclui muitos cabeçalhos opcionais além do Host. Por exemplo, considere a seguinte requisição:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1
Accept: text/html;q=0.9, */*;q=0.1
Accept-Charset: ISO-8859-1, utf-8;q=0.66, *;q=0.66
Accept-Language: en

Este exemplo inclui quatro cabeçalhos opcionais, User-Agent, Accept, Accept-Charset, e Accept-Language. Como estes cabeçalhos são opcionais, não é muito inteligente contar com sua presença. Contudo, se o browser de um usuário envia estes cabeçalhos, é seguro assumir que eles estarão presentes nas requisições subsequentes? A resposta é sim, com poucas exceções. Assumindo o exemplo anterior como sendo uma requisição enviada de um usuário atual com uma sessão ativa, considere a seguinte requisição subsequente enviada pouco depois:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345
User-Agent: Mozilla/5.0 (compatible; IE 6.0 Microsoft Windows XP)

Como o mesmo identificador único está sendo apresentado, a mesma sessão PHP será acessada. Se o browser está identificando a si mesmo de forma diferente do que na interações anteriores, nós devemos assumir que é o mesmo usuário?

Está claro que isto não é desejável, mas é exatamente isto o que acontece se você não escreveum código que especificamente não checa situações assim. Mesmo nos casos onde você não consegue ter certeza que a requisição é um ataque de personificação, simplesmente pedir que a senha ao usuário pode ajudar a prevenir a personificação sem afetar demais os uauários adversamente. Isto é um ponto importante.

Você pode adicionar a validação do User-Agent ao seu modelo de segurança de forma similar à lista 3.

Lista 3:

<?php
session_start();

if (md5($_SERVER['HTTP_USER_AGENT']) != $_SESSION['HTTP_USER_AGENT']) {
/* Prompt for Password */
exit;
}

/* Rest of Code */
?>

É claro, primeiro você precisará armazenar o digest MD5 do user agent que iniciou a sessão, como mostrado na lista 4.

Lista 4:

<?php
session_start();

$_SESSION['HTTP_USER_AGENT'] = md5($_SERVER['HTTP_USER_AGENT']);
?>

Enquanto não é necessário que você o MD5 do User-Agent, isso ajuda a providenciar consistência e elimina a necessidade de filtrar $_SERVER['HTTP_USAR_AGENT'] antes de usá-la. Como essa informação é originada de uma fonte remota, não podemos confiar de forma cega nela, mas o formato de um digest MD5 é consistente.

Agora que você exige a consistência de User-Agent, um atacante deve cumprir dois passos para roubar a sessão:

  1. Capturar um identificador de sessão válido.
  2. Apresentar o User-Agent da vítima na tentativa de personificação.

Enquanto isto é claramento possível, é ligeiramente mais complicado, e desta forma o mecanismo de sessão já está mais seguro.

Outros cabeçalhos podem ser adicionados desta forma, e você pode até mesmo usar uma combinação de cabeçalhos como uma impressão digital. Se você também incluir algum tipo de revestimento de algum tipo, esta impressão digital se torna praticamente impossível de adivinhar. Considere o exemplo da lista 5.

Lista 5:

<?php

session_start();

$fingerprint = 'SHIFLETT' . $_SERVER['HTTP_USER_AGENT'];
$_SESSION['fingerprint'] = md5($fingerprint . session_id());

?>

O cabeçalho Accept não deve ser usado nesta impressão, porque alguns browsers podem variar o valor deste cabeçalho quando o usuário atualiza a página.

Com uma impressão digital que é difícil de adivinhar, pouco é ganho não usando-a. Considere um mecanismo de sessão onde a impressão digital é propagada como o identificador de sessão. Nesta caso, um atacante deve completar os três passos seguintes para roubar uma sessão com sucesso:

  1. Capturar um identificador de sessão válido.
  2. Apresentar os mesmo cabeçalhos HTTP usados para gerar a impressão.
  3. Apresentar a impressão digital da vítima.

Se ambos o identificador de sessão e a impressão digital são propagadas como dados GET, ainda é possível que um atacante que obtenha um também consiga ter acesso ao outro. Uma abordagem mais segura é utilizar dois métodos diferentes de propagação, dados GET e cookies. É claro, isto depende das preferências do usuário, mas um nível extra de proteção pode ser oferecido para aqueles que habilitam os cookies. Assim, se um atacante obtém um identificador único por uma vulnerabilidade do browser, a impressão digital ainda continua desconhecida.

Existem muitos outros mecanismos que podem ser usados para ajudar a fortalecer a segurança do seu mecanismo de sessões. Esperamos que você esteja no caminho de criar as suas próprias técnicas. Afinal, você é o expert das suas próprias aplicações, então munido com um bom entendimento de sessões, você é a melhor pessoa para implementar alguma segurança adicional.

Obscuridade


Eu gostaria de desfazer um mito sobre a obscuridade. O mito é de que "não existe segurança através da obscuridade". Como mencionei antes, obscuridade não é algo que oferece a proteção adequada, nem deve ser tomada por base. Contudo, isso não significa que não há absolutamente nada a ser ganhar. Resguardado por um mecanismo seguro de sessões, obscuridade pode oferecer um pouco de segurança adicional.

O simples uso de nomes de variáveis que induzam ao erro para o identificador de sessão e para a impressão digital já ajudam. Você também pode propagar dados de engodo para confundir um potencial atacante. Estas técnicas certamente não devem ser usadas como a base para proteção, é claro, mas você não irá perder seu tempo implementando um pouquinho de obscuridade no seu próprio mecanismo.

Sumário


Eu espero que você tenha ganho diversas coisas deste artigo. Notavelmente, agora você deve ter um entendimento básico de como a web funciona, de como o estado completo é alcançado, o que é realmente um cookie, como as sessões do PHP funcionam, e algumas técnicas que você pode usar para aumentar a segurança das suas sessões.

Se você gostou deste artigo, você pode estar interessado em outros:


Se você desenvolver um mecanismo de sessões seguro por conta própria, por favor, sinta-se à vontade para compartilhar com a comunidade. Eu adoraria ouvir sobre suas próprias soluções, e eu espero que este artigo tenha fornecido as informações de base necessárias para dar suporte à sua própria criatividade.

----------- keepReading

terça-feira, 25 de maio de 2010

Robots.txt - Ajudando os buscadores

Voltamos a mais um artigo sobre boas práticas de web.

O assunto de hoje não tem a ver diretamente com usuários, e sim com os buscadores: robots.txt

O que é?

O arquivo robots.txt é algo extremamente simples. De verdade. É um arquivo, com o nome "robots.txt", que deve ficar na raíz do site, e com um conteúdo similar a:

User-agent: *
Disallow: /img/
Disallow: /styles/
Disallow: /scripts/
Disallow: /busca.php

Explicação

Na primeira linha definimos o user-agent, que nada mais é que o nome do crawler. No caso especificamos *, curinga para todos os crawlers. Para saber melhor quais os nomes válidos, veja a lista completa.

Nas outras linhas temos Disallow, que é a dica de quais diretórios e arquivos não indexar. No caso acima, dizemos que todo o conteúdo dos diretórios img, scripts e styles não devem ser indexados, e que o arquivo /busca.php também não.

Outras opções

Existem várias outras opções que não fazem parte do padrão como
  • Allow - funciona como o disallow, mas ao invés de proibir, permite
  • Delay - diz qual o intervalo em segundos entre uma requisição e outra
  • Request-rate - que diz qual a taxa de requisições.
  • Visit-time - diz qual o melhor intervalo para visitação do crawler
  • Sitemap - diz onde está o sitemap xml do site.

O que usar?

É muito incomum ver nos robots.txt existentes, alguma diretiva que fuja do padrão (user-agent e disallow), com exceção da diretiva sitemap. Para os crawlers dos maiores buscadores (google, yahoo, bing, ask), o uso dessa diretiva é bastante útil, então o uso da diretiva sitemap é recomendado.

Considerações

Assim como o sitemap, a função do robots.txt é meramente informativa. O trabalho de indexação acontece de forma independente. Um badbot pode - e provavelmente irá - ignorar uma cláusula de disallow. Para evitar a indexação de informações privilegiadas, use o .htaccess.

Mas sem neuroses, a existência do robots.txt no seu site indica a preocupação em ajudar os crawlers na tarefa de indexação, e isso com certeza conta alguns pontos para uma melhor colocação do site. É mais poderoso ainda se você indicar um sitemap.

Exemplo final

User-agent: *
Disallow: /scripts/
Disallow: /styles/
Disallow: /private/
Disallow: /busca.php
Sitemap: http://www.seusite.com/sitemaps/sitemap.xml

Até a próxima.
----------- keepReading

segunda-feira, 24 de maio de 2010

Sitemaps -- Como fazer e o que fazer com eles

Fala pessoal, vamos continuar o assunto de boas práticas e de design voltado ao usuário que abordei nos dois últimos posts desse blog.

Os sitemaps são uma poderosa ferramenta de organização e SEO. Alguns buscadores aceitam que você envie o sitemap o seu site. Assim eles sabem exatamente o que indexar, ao invés de apenas ir navegando e filtrando. Outro lugar onde você pode fazer referência ao seu sitemap é no arquivo robots.txt (falaremos brevemente sobre esse arquivo num post futuro).

Isso sem contar que um sitemap em XML pode servir de base para que você crie seu sitemap HTML (seja server-side, ou com transformação XSLT).

Chega de papo. Vamos ao que interessa. Um arquivo sitemap é nada mais que um arquivo XML, com o seguinte formato:

O arquivo de sitemap

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url>
  <loc>http://www.example.com/</loc>
  <lastmod>2005-01-01</lastmod>
  <changefreq>monthly</changefreq>
  <priority>0.8</priority>
 </url>
</urlset>

Explicando cada tag.
urlset - é a raíz do arquivo. Só pode existir uma.
url - é usada para englobar as propriedade de cada página. Cada página do site precisa de um conjunto desses.
loc - é o endereço da página. Importante: esse endereço deve ser escapado. Mais detalhes abaixo.
lastmod - é a data da última modificação da página, no formato AAAA-MM-DD
changefreq - é a frequencia com que a página tem seu conteúdo atualizado (aceita os valores always, hourly, daily, weekly, monthly, yearly, never - sempre, horário, diário, semanal, mensal, anual, nunca respectivamente).
priority - define a prioridade da página em relação ao site. Os valores vão de 0.01 a 1.00

Explicações

As tags lastmod, changefreq e priority são opcionais. Note que o changefreq dá apenas uma indicação aos buscadores. Uma página marcada com always ou hourly pode ser indexada com uma frequencia menor do que isso. Uma página marcada com yearly, pode ser indexada mais de uma vez por ano. Ou seja, ela é apenas uma dica. A indexação de fato é feita pelos buscadores, e não há como garantir isso com precisão absoluta.

Para sites dinâmicos, criar o sitemap na mão pode ser bastante complicado. Então podemos criar um script que gere o sitemap. Eu criei um script rápido em PHP que faz isso.

Outra observação a ser feita é em relação ao uso da tag priority. Setar todas as páginas com prioridade 1.00 (mais importante) é uma tentação como todas as outras práticas de black hat SEO. Não faça isso!

Na dúvida deixe o valor 1.00 para a home, e outros valores mais baixos para outras páginas. Uma boa abordagem seria contar quantos níveis existem no path para cada página, e daí sim basear o valor de cada página. Por exemplo, para o endereço http://www.seusite.com.br/artigos /subcategoria/nome-do-artigo.html, vemos a seguinte estrutura:
0 - http://www.seusite.com.br/
1 - http://www.seusite.com.br/artigos/
2 - http://www.seusite.com.br/artigos/subcategoria/
3 - http://www.seusite.com.br/artigos/subcategoria/nome-do-artigo.html

Daí podemos fazer a seguinte associação de valores:
0 - 1.00
1 - 0.85
2 - 0.80
3 - 0.75

Ou mesmo inverter os dois últimos números, 0.80 e 0.75 (isso porque o conteúdo de um artigo geralment é mais importante do que o índice, mas uma seção de artigos é mais importante que um artigo sozinho).

Uma outra abordagem para calcular o valor da prioridade seria ver qual o real valor do conteúdo de cada página para o site. Vamos supor que você escreveu um artigo muito bom, ou tem uma página de produtos que atrai mais visitas que sua própria página inicial - em outros termos, você tem uma outra fonte de entrada muito boa no seu site.

É normal e aceitável que esta página tenha um valor de prioridade maior na indexação, podendo ser mesmo 1.00 (> 80% das visitas vindo por mecanismos de busca achem seu site por esta página).

Em suma: o bom senso deve imperar.

E o escaping das URLs?

Pra fechar, deixe-me falar sobre o valor da tag mais importante de cada URL, a tag loc.
O valor para esta tag que contém a URL deve ser uma URL escapada - com os carateres especiais codificados.

Por exemplo, a URL http://www.seusite.com.br/usuários/josé123 deverá ser escrita no sitemap como
http://www.seusite.com.br/usu%C3%A1rios/jos%C3%A9.

Esse resultado pode ser obtido pelo javascript, usando a função encodeURI(), ou no PHP, com a função encodeurl. Note que o PHP também faz o encoding dos caracteres especiais como ":" e "/".

No meu script há uma ligeira adaptação da função encodeURL. Eu uso a função encodeURL, e depois a str_replace para voltar os caracteres de controle ao normal.

Bom, isso é tudo. No próximo artigo, um tapa no robots.txt. Até lá.
----------- keepReading

sexta-feira, 21 de maio de 2010

Páginas de erro 404 úteis - Nos bastidores

No artigo passado sobre páginas de erro 404 úteis, vimos que existem possibilidades de sugestões e alternativas para ajudar pessoas e navegadores a encontrar o conteúdo que procuram.

Agora é hora de uma pitada técnica sobre os cabeçalhos HTTP envolvidos nesse processo, e como eles afetam sua página nos buscadores.

É de uso comum e corrente, que quando uma página não é encontrada, se faça um redirecionamento para uma página padrão, como a página de entrada. Como seguinte trecho de PHP:
<?php
header("Location http://www.seusite.com.br/");
?>

O problema dessa implementação é bem simples. Você envia junto com esse header Location, um cabeçalho HTTP 302 (Found).

Vamos supor que um indexador (googlebot, ou qqr outro) veja um link num outro site, apontando para o seu, mas com o endereço para uma página que não existe, e deveria lançar um erro 404 - porque ela não existe!

Sua manipulação com o simples header location, ou mesmo com um redirect 301 no .htaccess vai enviar o código errado, e o indexador vai entender essa página inexistente como uma existente. Pior, pode ser que ela indexe conteúdo duplicado (muitos links diferentes que apontam para uma mesma página). O que é uma má prática bad SEO.

Quando criar a sua página de erro para páginas não encontradas, SEMPRE se assegure que vai enviar o cabeçalho HTTP 404.

Em PHP o código é bem simples.
<?php
header($_SERVER["SERVER_PROTOCOL"]." 404 Not Found");
?>
//código da página de erro amigável

Assim, você garante a correta indexação e a consistencia entre o seu sitemap XML, e as páginas válidas no seu site.

No próximo post: sitemaps.
----------- keepReading

Criando páginas 404 úteis

As famosas páginas de error 404 - Documento não encontrado são um saco. Ninguém gosta de clicar num link e ver uma página de erro, em branco asséptico, com a única opção de voltar ou ver se digitou errado (quando vc digita o endereço ainda vai, o problema é quando vc clica e cai numa página de erro.)

Bom, ninguém gosta dessas páginas. Nem os motores de busca. Mas o que fazer? Bom, é dever de quem faz web com qualidade, cuidar para providenciar alternativas amigáveis.
  • Sugestões
  • Mapa do site
  • Busca no site
Vamos por partes. E partir do pressuposto que você tem um mapa do site (sitemap). Ou melhor, dois. Um sitemap XML e um HTML. Num futuro proximo escreverei sobre Sitemaps. Por enquanto basta saber que é basicamente uma coleção de links que de fato existem e são válidos no seu site.

Agora mais uma suposição de uma página de conteúdo seu. http://www.seusite.com.br/viagens/recife.html

Esta sua página foi linkada ou enviada por algum amigo seu, por engano como http://www.seusite.com.br/viagens/reci

Isso mesmo, truncada. Quando alguém clicar, invariávelmente vai cair numa página de erro 404, porque essa página não existe. Aqui é onde os truques começam.

A forma mais simples de processar isso seria procurar entre os links que vc tem como válidos no seu sitemap (a versão XML é melhor para isso, por facilidade de implementação), um link que tenha o endereço informado como parte e sugerir esse(s), links.

Por exemplo,
Páginas mais próximas:
http://www.seusite.com.br/viagens/recife.html
http://www.seusite.com.br/viagens/recitais_em_gramado.html

Bem melhor, não? Ter alternativas válidas ao invés de uma mensagem de erro apenas.

Mas podemos melhorar ainda mais dando uma alternativa à raiz do diretório imediatamente anterior. No caso, o link para http://www.seusite.com.br/viagens/

Fora essas sigestões de links, nos restam como alternativas:
Oferecer o link para o sitemap em versão html, e oferecer uma busca no site.

http://www.seusite.com.br/mapa_do_site/



Como resultado final, se alguém clicar num link para http://www.seusite.com.br/viagens/reci vai ser levado às seguintes sugestões:

http://www.seusite.com.br/viagens/recife.html
http://www.seusite.com.br/viagens/recitais_em_gramado.html
http://www.seusite.com.br/viagens/
http://www.seusite.com.br/mapa_do_site/


Ótimo. Agora ao invés de ter uma página de erro que enche o saco, temos uma página de erro que ajuda as pessoas e os buscadores através de alternativas e sugestões.

Até o próximo artigo onde vou explicar uma parte mais técnica para a implementação.
----------- keepReading

sexta-feira, 14 de maio de 2010

Validações em PHP

Andei trabalhando bastante com web esses últimos tempos, e uma coisa que sempre consome muito tempo e neurônios é segurança em geral.

Até que eu encontrei uns artigos do Chris Shifflet. Todos artigos do cara são muito bons. Vale a pena dar uma lida com carinho.

Eu já havia lido algumas coisas publicadas por ele, mas apenas para Sessões PHP. Desta vez encontrei uma frase que mudou meu conceito de segurança em geral num artigo sobre XSS e CSRF.

"Instead of trying to predict what malicious data you want to reject, define your criteria for valid data, and force all input to abide by your guidelines."/cite>

Ou em português... "Ao invés de tentar adivinhar quais dados maliciosos você quer rejeitar, defina seu critério para dados válidos, e force todas entradas a obedecer suas regras.".

Isso não só me foi útil para definir critérios de validação de dados, mas também como design de software como um todo.

Aliado a boas práticas de outras áreas, isso se torna algo realmente valioso, pois economiza muitas e muitas linhas de código e neurônios.

----------- keepReading

terça-feira, 23 de março de 2010

HTML 5 e CSS 3

Já faz algum tempo (desde 2007 pelo que eu vejo), alguns blogs e portais de desenvolvimento vem falando sobre as novas versões das linguagens mais comuns para marcação e estilo usadas para web.

Com o boom da web 2.0 e com os buscadores valorizando mais o conteúdo, visando uma web mais útil, rica e interativa, a tendência de que as linguagens evoluissem para acompanhar os rumos e necessidades, tanto de desenvolvedores, quanto dos seus clientes.

Mas o que é e quais são as novidades? Não, não vou fazer um tutorial de 3 minutos falando sobre as novas tags e seletores por dois motivos: existem diversos tutoriais disponíveis, para todos os gostos, e porque ontem me deparei com uma seção sobre isso no W3C que me deixou um tanto quanto curioso.

O HTML5, além de incluir novas tags, propriedades e valores chave, trabalha um novo conceito, uma nova abordagem, em termos de design de conteúdo e de composição. Antes, no HTML 4, haviam elementos de bloco e elementos inline à nossa disposição, que poderiam ser arranjados afim de construir a navegação e o layout. Agora, não existe mais essa diferença (na verdade ainda existe), mas o enfoque é mais semântico. O HTML 5 trabalha em suas especificações com o conceito de modelo de conteúdo, ao invés do conceito de elementos de bloco e de linha.

O ponto negativo do HTML5, apesar da especificação bem mais madura que anos atrás, ainda é a falta de suporte nos navegadores.

Já o CSS3, é melhor suportado pelos navegadores atualmente. Ele não traz grandes novidades em termos semânticos ou de abordagem para implementação, e sim facilidades através de seletores e propriedades. Bordas arredondadas, text-shadow, e talvez a maior delas no meu ponto de vista, tipografia.

No próximo post, falarei sobre outras tecnologias que estão despontando com força sobre web semântica e SEO: RDFa e Microformats.

-----------
keepReading

terça-feira, 8 de dezembro de 2009

Santos Dummont era open source

Tirando as teias de aranha daqui, volto com um post que foge da linha técnica.

Deixa eu começar com uma história que me aconteceu uns dias atrás. Uma amiga minha, a Jaque, começou a fazer uns cursos voltados para desenvolvimento web. Ela, designer, ficou um tanto espantada com a complicação que é fazer a coisa direito (tags, HTML x XHTML, CSS, seletores, propriedades, navegadores diferentes renderizam diferente, preocupação com múltiplas plataformas, navegadores, resoluções de tela).

Também pudera, qualquer pessoa que entra no mundo de fazer web a sério desanima quando topa com toda essa complicação técnica. Eu conversei com ela, expliquei, mostrei algumas ferramentas legais (como alguns addons MUST HAVE do Firefox...). E depois de um tempo, lembrei que eu tinha feito a tempos atrás uns mock-ups praticamente bullet proof.

Uns esqueletões em XHTML e CSS, com direito a menuzinho bacana e tudo o mais, cross-browser (não cheguei a testar no IE8, no FF 3.5, nem no Opera 10... ainda), adaptável a várias resoluções, e por aí vai. Claro que a intenção não era dispensar o trabalho de um designer ou de um programador, mas pelo menos para essa parte chata, burocrática e que consome um tempo enorme do desenvolvimento poupar tempo, bastando apenas editar cores, bordas, fontes, espaçamentos e rechear com as imagens.

Enviei pra ela (pro namorado dela e para mais dois amigos). Ela achou bacana, completamente crú, mas dentro da proposta de facilitar as coisas. E eis que ela me lança a pergunta: "Hey, pq vc não vende isso?". Na hora fiquei meio sem reação, mas respondi que é pq eles eram meus amigos, oras.

Mas no fundo, é o mesmo motivo pelo qual eu escrevo e publico tutoriais ao invés de dar aulas particulares. É porque eu encaro o conhecimento como um bem para a humanidade. É isso. Tem gente que não entende, ou não concorda, ou ainda que acha insanamente altruísta esse lance todo.

Pode ser. Afinal, vamos a uma análise do processo. Construir algo de útil demanda recursos. Muitos recursos. No caso do software não é qualquer pessoa apta a criar algo, muito menos com qualidade e refinamento. Demanda muito tempo e dedicação, muito estudo, tentativa e erro, refinamento, leitura e aprendizado de novas técnicas... Mas depois que você tem algo relativamente satisfatório em mãos, não há muito mais o que fazer. O custo para a reprodução, replicação é MUITO baixo. Ao contrário de fazer um trem por exemplo, que demanda muita matéria prima, o software não demanda praticamente nada.

Esse é um dos pontos. Um outro é compartilhar conhecimento. Vamos tomar por base algum framework, como o Rails, o Kohana, ou o JQuery. Sem dúvida dá pra aprender muito e/ou aprofundar seriamente os conhecimentos apenas lendo os códigos deles. E sim, eu acredito que pessoas que fazem isso, que leem códigos levam o que fazem a sério, então nada mais justo do que compartilhar conhecimento com essas pessoas. Um dia mais tarde elas podem - e quase sempre realmente fazem isso - ajudar a aprimorar algo que também seja Open Source.

Ler códigos, analisar e entender, é uma das melhores práticas para se aprender alguma nova técnica e assim melhorar a qualidade do seu serviço, ou notar onde vc estava errando na sintaxe/raciocínio.

OK, falei do caso software, baixo custo de reprodução, vantagens à comunidade que realmente sabe e gosta do que faz. Mas e as outras coisas? Outros produtos e bens. Vamos terminar com um pouco de história.

Eu falei do trem. Para produzir um são necessários vários recursos. Mas e a planta, os rascunhos, o processo? Nada mais são do que folhas com anotações, desenhos, valores chave.... De posse desses documentos, qualquer pessoa com condições de ler e interpretar, e tendo os recursos necessários poderia reproduzir o produto em questão. seja uma folha de papel, ou um foguete.

Santos Dummont tinha essa visão, e também alegava que o conhecimento é um bem para a humanidade. Todos os seus projetos eram o que poderíamos chamar hoje de Open Source.

Assim, creio que nossa sociedade ainda não está evoluída a tal ponto, mas há indivíduos que já tem essa perspectiva de contribuição científica e cutural (hoje temos mais que antes) e dos benefícios que essa partilha trás.

É isso, até a próxima.
-----------
keepReading