Codificando os parâmetros de uma URL no PHP

Quando se utiliza o método GET os parâmetros de solicitação, codificados como pares de nome e valor, ficam visíveis na URL do script que trata a solicitação HTTP. Isto torna o GET menos seguro, comparado ao POST, porque os dados são enviados como parte da URL e assim, além da URL estar visível à qualquer um, pode ser adicionada no favoritos, armazenada no cache e permanecer no histórico do navegador.

Exemplo de URL com parâmetros no script PHP:

http://www.site.com/index.php?op=L&md=D&id=8

É comum utilizar parâmetros no script como meio de especificar as funções que serão executadas ou também como passagem de valores para variáveis ou funções. Se a navegação no site pode ser manipulada apenas adulterando o valor de um parâmetro na URL, ou se há alguma informação relativamente importante que precisa ser passada por parâmetro na URL, é uma boa medida proteger o site dos bisbilhoteiros. Uma solução é esconder os parâmetros da URL, adicionalmente com outras medidas de segurança.

Não quero neste artigo ditar regras de segurança para sites. Quero apenas mostrar uma solução simples e alternativa para proteger a URL, sem uso das ferramentas convencionais e sérias de criptografia. Nesta solução caseira, é usado uma combinação de comandos nativos do PHP para dar um certo efeito de criptografia.

Uma forma de esconder os parâmetros é codificá-los em caracteres ilegíveis. Somente o script que manipula a solicitação saberá decodificá-los, como se fosse uma criptografia.

Exemplo de URL com parâmetros codificados:

http://www.site.com/index.php?p=dpECApXucSffrhH0VfFOTWgfFyIErbMOTv4ZT5EEvEEWrE

Um método simples de codificação e decodificação é o Base64. O Base64 é um método para codificação de dados para transferência na Internet. Útil na transmissão de dados binários por meios que lidam apenas com texto, por exemplo, enviar arquivos por email. O Base64 codifica qualquer dado em uma sequência de caracteres dentre 64 caracteres distintos (A-Z, a-z, 0-9, + e /). Por exemplo, o texto "ola mundo", convertido para Base64 se torna "b2xhIG11bmRv". Existem diversas variações do Base64 mas não importa aqui.

Entretanto, o Base64 não é uma criptografia, é apenas uma codificação. Na codificação os dados são facilmente convertidos de uma representação para outra, sem a necessidade de uma chave, apenas do algoritmo. O algoritmo Base64 é bastante comum e seu uso é fácil de ser percebido. Usar somente ele não adiantaria muito no propósito de esconder os parâmetros.

Para camuflar o Base64 pode-se usar uma sequência de eventos em uma função que irá codificar ou decodificar a URL. Esta sequência, inventada pelo programador, fica desconhecida para quem tem acesso a página HTML apresentada no navegador pois está no código fonte do script. Praticamente uma criptografia onde a chave é o algoritmo em si.

A seguir tem um exemplo de implementação desta solução em PHP. A classe "cripto" contém as funções que irão codificar e decodificar a URL. Nelas, algumas funções nativas do PHP foram usadas para camuflar o Base64:

A função "strtr", retorna uma cópia da string, traduzindo todas as ocorrências de cada caractere do primeiro conjunto para o caractere correspondente no segundo conjunto; A função "substr" retorna a parte da string a partir do parâmetro especificado; A função "strrev" retorna a string invertida; Por fim, a função "base64_encode" codifica a string e a função "base64_decode" decodifica a string.

A ideia deste exemplo é codificar a string original, invertê-la e adicionar um prefixo aleatório, repetindo tudo isso por três vezes. Este prefixo é para confundir o resultado final, impossibilitando a decodificação direta. Como se não fosse o bastante, os caracteres da string resultante são trocados, gerando outra confusão no resultado final. Segue a classe de exemplo:

class cripto {
 
  function codificar($str) {
    $prfx = array('AFVxaIF', 'Vzc2ddS', 'ZEca3d1', 'aOdhlVq', 'QhdFmVJ', 'VTUaU5U',
                  'QRVMuiZ', 'lRZnhnU', 'Hi10dX1', 'GbT9nUV', 'TPnZGZz', 'ZGiZnZG',
                  'dodHJe5', 'dGcl0NT', 'Y0NeTZy', 'dGhnlNj', 'azc5lOD', 'BqbWedo',
                  'bFmR0Mz', 'Q1MFjNy', 'ZmFMkdm', 'dkaDIF1', 'hrMaTk3', 'aGVFsbG');
    for($i=0; $i<3; $i++) {
      $str = $prfx[array_rand($prfx)].strrev(base64_encode($str));
    }
    $str = strtr($str,
                 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
                 "a8rqxPtfiNOlYFGdonMweLCAm0TXERcugBbj79yDVIWsh3Z5vHS46pQzKJ1Uk2");
    return $str;
  }
 
  function decodificar($str) {
    $str = strtr($str,
                 "a8rqxPtfiNOlYFGdonMweLCAm0TXERcugBbj79yDVIWsh3Z5vHS46pQzKJ1Uk2",
                 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
    for($i=0; $i<3; $i++) {
      $str = base64_decode(strrev(substr($str,7)));
    }
    return $str;
  }
 
  function separar_parametros($param) {
    return explode('&',$param);
  }
 
  function separar_valor($opcao) {
    return explode('=',$opcao);
  }
 
}

No script que irá montar a página HTML, no momento da edição da etiqueta "a" ou de outra etiqueta que use uma URL, chama-se a função "codificar", da classe "cripto", para gerar a URL do atributo "href". Os parâmetros originais são transformados em um único valor para o parâmetro "p", que será coletado na solicitação. O parâmetro "p" ficará visível na URL mas seu valor estará codificado. Segue alguns exemplos de aplicação da função "codificar":

'<a href="index.php?p='.$this->cripto->codificar("op=F&md=E").'">'

'<a href="cliente.php?p='.$this->cripto->codificar("op=A&md=F&id=".$idcliente).'">'

'<button type="button" value="Cancelar" onclick="location.href=\'index.php?p='.$this->cripto->codificar("op=A&md=I").'\'">Cancelar</button>'

header("Location: index.php?p=".$this->cripto->codificar('op=L&md=C'));

Por sua vez, o script invocado pela URL deve ler o valor do parâmetro "p" que está na variável $_GET, variável predefinida que coleta valores no método GET, e executar a função de decodificar. Após a decodificação, a string com os pares originais (nome e valor) deve ser separada nos parâmetros originais e seus respectivos valores e armazenados em variáveis que serão utilizadas no decorrer do script PHP. Segue exemplo:

$cripto = new cripto;

$param = isset($_GET["p"]) ? $_GET["p"] : '';
$op = $md = $id = '';
$parametros = $cripto->separar_parametros($cripto->decodificar($param));
foreach($parametros as $opcao) {
  $valor = $cripto->separar_valor($opcao);
  if ($valor[0]=='op') $op = $valor[1];
  elseif ($valor[0]=='md') $md = $valor[1];
  elseif ($valor[0]=='id') $id = $valor[1];
}

As funções auxiliares "separar_parametros" e "separar_valor" tratam a string decodificada. A função "explode", nativa do PHP, retorna uma matriz de strings, cada uma com uma substring formada pela divisão a partir do delimitador especificado.

Esta solução funciona muito bem para o propósito. O algoritmo criado para confundir a codificação Base64 é o segredo. O sucesso vai da imaginação do programador.

Uma limitação técnica desta solução é quanto ao limite do tamanho da URL. A URL é limitada a um tamanho máximo de 2048 caracteres. Os dados codificados em Base64 ficam aproximadamente 33% maiores que os dados originais. Realizando a codificação mais de uma vez e adicionando o prefixo, o resultado é bem maior. Mas é raro precisar de uma URL tão grande.