Problemas Da Corda Do Formato


  Share  
|


Os problemas da corda do formato são um de poucos ataques verdadeiramente novos a aplainar em anos recentes. Um dos primeiros mentions de erros da corda do formato realizava-se junho em 23, 2000, em um borne por Lamagra Argamal (www.securityfocus.com/archive/1/66842); O Pascal Bouchareine explicou-os mais claramente quase um mês mais tarde (www.securityfocus.com/archive/1/70552). Um borne mais adiantado por Marca Slemko (www.securityfocus.com/archive/1/10383) anotou os princípios do problema, mas faltou a abilidade de erros da corda do formato de escrever a memória.

Como com muitos problemas da segurança, a causa da raiz de erros da corda do formato está confiando em entrada user-supplied sem validation. Em C/C++, os erros da corda do formato podem ser usados escrever às posições de memória arbitrárias, e o aspecto o mais perigoso é que este pode acontecer sem alterar os blocos adjacentes da memória. Esta potencialidade fine-grained permite que um atacante contorneie proteções da pilha, e modifica mesmo parcelas muito pequenas da memória. O problema pode também ocorrer quando as cordas do formato são lidas do untrusted a posição que o atacante controla. Este último aspecto do problema tende a ser mais prevalent em sistemas de UNIX e de Linux. Em sistemas de Windows, as tabelas de corda da aplicação são mantidas geralmente dentro do programa executável, ou das bibliotecas de ligação dinâmicas do recurso (DLLs). Se um atacante puder reescrever o executável principal ou o recurso DLLs, o atacante pode executar muitos mais ataques diretos do que erros da corda do formato.

Mesmo se você’re não tratar do C/C++, ataques da corda do formato pode ainda conduzir aos problemas consideráveis. O mais óbvio é que os usuários podem misled, mas sob algumas circunstâncias, um atacante pôde também lançar ataques scripting do cruz-local ou de injeção do SQL. Estes podem ser usados corrupt também ou transformar dados.

Línguas Afetadas

A língua o mais fortemente afetada é C/C++. Um ataque bem sucedido pode conduzir imediatamente à execução do código arbitrário, e à divulgação da informação. O outro t ganhado’línguas permite tipicamente a execução do código arbitrário, mas outros tipos de ataques são possíveis como nós anotamos previamente. O isn t’do Perl diretamente vulnerável aos specifiers que estão sendo dados pela entrada do usuário, mas poderia ser vulneráveis se as cordas do formato fossem lidas dentro dos dados alterados.

O Sin Explicou

Os dados do formato para a exposição ou o armazenamento podem ser uma tarefa um tanto difícil. Assim, muitas línguas de computador incluem rotinas para reformat fàcilmente dados. Em a maioria de línguas, a informação do formato é descrita usando alguma sorte de uma corda, chamada a corda do formato. A corda do formato é definida realmente usando língua de processo de dados limitada que’s projetou a fazer fácil de descrever formatos da saída. Mas muitos colaboradores fazem um erro que fácil—usam dados de untrusted usuários como a corda do formato. Em conseqüência, os atacantes podem escrever cordas na língua de processo de dados para causar muitos problemas.

O projeto de C/C++ faz este especial perigoso: O projeto’de C/C++ s faz mais duro detectar problemas da corda do formato, e as cordas do formato incluem alguns comandos especial perigosos (particularmente %n) que não existem em algumas outras línguas’ da corda do formato das línguas.

Em C/C++, uma função pode ser declarada para fazer exame de um número variável dos argumentos especificando um ellipsis (…) como o último (ou somente) argumento. O problema é que a função que está sendo chamada não tem nenhuma maneira saber apenas quantos argumentos estão sendo passados dentro. O jogo o mais comum das funções para fazer exame de argumentos do comprimento variável é a família do printf: printf, sprintf, snprintf, fprintf, vprintf, e assim por diante. As funções largas do caráter que executam a mesma função têm o mesmo problema. Deixe’a tomada de s um olhar em uma ilustração:

# inclua < stdio.h >

argc do main(int, char internos * argv[ ])
{
if(argc > 1)
printf(argv[1 ]);

retorno 0;
}

Material razoavelmente simples. Deixe agora’s olhar o que pode ir erradamente. O programador está esperando o usuário incorporar algo benigno, como hello o mundo. Se você lhe der uma tentativa, você’ll começa para trás hello o mundo. Deixe agora’a mudança de s a entrada um pouco—a tentativa %x %x. Em um sistema de Windows.xp usando a linha de comando do defeito (cmd.exe), você’ll começa agora o seguinte:

E:\projects\19_sins\format_bug>format_bug.exe "%x %x"
12ffc0 4011e5

Anote que se você’re funcionar um sistema se operando diferente, ou está usando uma linha de comando diferente intérprete, você pode necessitar fazer algumas mudanças para começar esta corda exata alimentada em seu programa, e os resultados serão provavelmente diferentes. Para a facilidade de utilização, você poderia pôr os argumentos em um certificado de escudo ou em uma lima de grupo.

Que aconteceu? A função do printf fêz exame de uma corda da entrada que fizesse com que esperasse dois argumentos ser empurrada na pilha antes de chamar a função. Os specifiers de %x permitiram-no de ler a pilha, quatro bytes de cada vez, até você’d como. Ele isn’t duramente para imaginar que se você tiver uma função mais complexa que armazenasse um segredo em uma variável da pilha, o atacante poderia então ler o segredo. A saída aqui é o endereço da posição da pilha (0x12ffc0), seguido pela posição do código em que a função do main() retornará. Como você pode imaginar, ambos o estes são as partes de informação extremamente importantes que estão sendo escapadas a um atacante.

Você pode agora querer saber apenas como o atacante usa um erro da corda do formato escrever a memória. Um de menos specifiers usados do formato é %n, que escreve o número dos caráteres que devem ter sido escritos assim distante no endereço da variável que você deu como o argumento correspondente. Aqui’s como deve ser usado:

bytes internos não assinados;
printf("%s%n\n", argv[1 ], &bytes);
a entrada do printf("Your era long\n, bytes dos caráteres de %d");

A saída seria:

E:\projects\19_sins\format_bug>format_bug2.exe "alguma entrada aleatória"

Alguma entrada aleatória

Sua entrada era 17 caráteres longos

Em uma plataforma com inteiros four-byte, o specifier de %n escreverá quatro bytes em uma vez, e %hn escreverá dois bytes. Agora os atacantes somente têm que figurar para fora de como começá-los ao endereço’d como na posição apropriada na pilha, e tweak os specifiers da largura do campo até que o número dos bytes escritos esteja o que’d gosta.

Para agora, deixe’s apenas supor que se você permitir que os atacantes controlem a corda do formato em um programa de C/C++, é uma matéria de tempo antes que figurem para fora de como o fazer funcionar seu código. Um aspecto especial nasty deste tipo de ataque é aquele antes de lançar o ataque, podem sondar a pilha e corrigir o ataque na mosca. No fato, a primeira vez que o autor demonstrou este ataque no público, usou-a uma linha de comando diferente intérprete do que ele’d usado criar a demonstração, e trabalho’do didn t. devido à flexibilidade original deste ataque, era possível corrigir o problema e explorar a aplicação de amostra com prestar atenção das audiências.

A maioria outras de línguas don’a sustentação de t o equivalente de um specifier do formato de %n, e aren’t diretamente vulnerável à execução fácil do código atacante-fornecido, mas você pode funcionamento imóvel em problemas. Há outro, uns variants mais complexos neste ataque que outras línguas são vulneráveis a. Se os atacantes puderem especificar uma corda do formato para a saída a uma lima ou a uma base de dados de registro, podem causar registros incorretos ou enganadores. Adicionalmente, a aplicação que lê os registros pode considerar os entrada confiada, e uma vez que esta suposição violated, fraquezas que o parser’da aplicação s pode conduzir à execução do código arbitrário. Um problema relacionado está encaixando caráteres de controle em limas que de registro—os retrocessos podem ser usados apagar coisas; alinhe terminais pode ofuscar ou mesmo eliminar os traços’do atacante s.

Isto deve ir sem dizer, mas se um atacante puder especificar a corda do formato alimentada ao scanf ou às funções similares, o disastre está na maneira.

Sinful C/C++

Ao contrário de muitas outras falhas nós’ll examinamos, este somos razoavelmente fáceis de manchar-se como um defeito do código. Ele’s muito simples:

printf(user_input);
é errado, e

printf("%s", user_input);
está correto.

Um variant no problema que a negligência de muitos programadores é que não é suficiente fazer corretamente isto somente uma vez. Há um número de construções comuns do código onde você pôde usar o sprintf colocar uma corda formatada em um amortecedor, e desliza então acima e faz este:

fprintf(STDOUT, err_msg);
O atacante então somente tem que craft a entrada de modo que os specifiers do formato sejam escapados, e em a maioria de casos, esta é uma versão muito mais fàcilmente explorada porque o amortecedor do err_msg será alocado freqüentemente na pilha. Uma vez que os atacantes controlam andar back-up a pilha,’ll possam controlar a posição que é escrita usando a entrada do usuário.

Sins Relacionados

Embora o ataque o mais óbvio seja relacionado a um defeito do código, é uma prática comum pôr cordas da aplicação em limas externas para finalidades do internationalization. Se sua aplicação tiver sinned não proteger a lima corretamente, a seguir um atacante pode fornecer cordas do formato por causa de uma falta do acesso apropriado da lima.

Um outro sin relacionado não está validando corretamente a entrada do usuário. Em alguns sistemas, uma variável de ambiente especifica a informação do locale, e o locale, por sua vez, determina o diretório onde as limas language-specific serão encontradas. Em alguns sistemas, o atacante pôde mesmo fazer com que a aplicação olhe em diretórios arbitrários.

Manchando o teste padrão do sin

Toda a aplicação que fizer exame do usuário input e passagens a uma função do formato está potencial no risco. Um exemplo muito comum deste sin acontece conjuntamente com as aplicações que registram a entrada do usuário. Adicionalmente, algumas funções podem executar o formato internamente.

Manchando o sin durante a revisão de código

Em C/C++, procure funções da família do printf. Os problemas a procurar são

printf(user_input);  
fprintf(STDOUT, user_input);

Se você vir uma função que olhe como esta:

fprintf(STDOUT, msg_format, arg1, arg2);

então você necessidade verificar onde a corda referenced pelo msg_format é armazenada e como bom é protegida.

Há muitas outras chamadas do sistema e APIs que é também syslog—vulnerável é um exemplo. Quando você vê uma definição da função que inclua … na lista do argumento, você’re olhar algo que é provável ser um problema.

Muitos varredores de código da fonte, mesmo lexicais gostam de RATOS e o flawfinder, pode detectar este. Lá’s PScan uniforme (www.striker.ottawa.on.ca/~aland/pscan/), que foi projetado especificamente para este.

Está opondo também as ferramentas que podem ser construídas no processo da compilação. Para o exemplo, lá’s Crispin Cowan’s FormatGuard: http://lists.nas.nasa.gov/archives/ext/linux-security-audit/2001/05/msg00030.html

Técnicas testando para encontrar o sin

Passe specifiers do formato na aplicação e veja se os valores hexadecimais forem retornados. Para o exemplo, se você tiver uma aplicação que espere um nome da lima e retorne uma mensagem de erro que contem a entrada quando a lima não pode ser encontrada, a seguir a tentativa que dá lhe a lima nomeia como NotLikely%x%x.txt. Se você começar uma mensagem de erro ao longo das linhas de "NotLikely12fd234104587.txt não pode ser encontrado," então você encontrou apenas um vulnerability da corda do formato.

Isto é obviamente um tanto language-dependent; você deve passar nos specifiers do formato que são usados pela língua de execução você’re se usar ao menos. Entretanto, desde que muitas vezes do funcionamento da língua são executadas em C/C++, você’d seja sábio de emitir também em comandos da corda do formato de C/C++ detectar os casos onde sua biblioteca subjacente tem um vulnerability perigoso.

Anote que se a aplicação for correia fotorreceptora baseada e ecoar seu usuário input para trás a você, um outro interesse seria ataques scripting do cruz-local

Sins Do Exemplo

As seguintes entradas nos vulnerabilities e nas exposições comuns (CVE) em http:// cve.mitre.org são exemplos da injeção do SQL. Fora das 188 entradas de CVE que as cordas do formato de referência, esta são justas uma amostragem.

CVE-2000-0573

Da descrição de CVE: “Lreply a função no wu-ftpd 2.6.0 e mais adiantado não cleanse corretamente untrusted a corda do formato, que permite que os atacantes remotos executem comandos arbitrários através do comando do LOCAL EXEC.”

Esta é a primeira façanha publicamente sabida para um erro da corda do formato. O título do borne de BUGTRAQ underscores a severidade do problema: “Fornecer * telecontrole * enraize desde ao menos 1994.”

CVE-2000-0844

Da descrição de CVE: “Algumas funções que executam o subsistema do locale em UNIX não cleanse corretamente cordas usuário-injetadas do formato, que permite que os atacantes locais executem comandos arbitrários através das funções tais como o gettext e catopen.”

O texto cheio do consultivo original pode ser encontrado em www.securityfocus.com/archive/1/80154, e este problema é especial interessante porque afeta o sistema APIs do núcleo para a maioria de variants de UNIX (Linux including), à exceção dos variants do DEB devido ao fato que a variável de NLSPATH está ignorada para aplicação privilegiada do suid no DEB. Este consultivo, como muitos advisories do NÚCLEO SDI, é especial escrita e informative bons e dá uma explanação muito completa do problema total

Etapas Do Redemption

A primeira etapa é nunca usuário da passagem input diretamente a uma função do formato, e seja também certa fazer isto a todos os níveis de segurar a saída formatada. Como uma nota adicional, as funções do formato têm despesas gerais significativas. Olhe a fonte para _ output se você’re interessado—ele puder ser conveniente de escrever:

fprintf(STDOUT, buf);

A linha precedente do isn t’do código apenas perigoso, mas consome também muitos de ciclos extra do processador central.

A segunda etapa a fazer exame é assegurar-se de que as cordas do formato seus usos da aplicação estejam lidas somente dos lugares confiados, e que os trajetos às cordas não podem ser controlados pelo atacante. Se você’re o código da escrita para UNIX e Linux, depois do exemplo dos variants e de ignorar do DEB a variável de NLSPATH, que pode ser usada especificar a lima se usar para mensagens localizadas, puder fornecer alguma defesa na profundidade.

Redemption de C/C++

Lá isn’t muito mais a ele do que este:

printf("%s", user_input);

Medidas Defensivas Extra

Verifique e limite o locale aos valores válidos. (para mais informação, veja o wheeler s’de David “o escrever seguro: Formate cordas e filtrar do locale” alistado “na outra seção” dos recursos abaixo). Don’o uso de t a printf-família das funções se você puder a evitar. Para o exemplo, se você’re usar C++, usar operadores do córrego preferivelmente:

# inclua < o iostream >  
/  
std::cout < < user_input  
/

Outros Recursos

este é um artigo adicionado por Hendra Fang


Share  
© 2005-2010 E-articles.info All Rights Reserved - Terms and conditions