Overruns Do Amortecedor


  Share  
|


Os overruns do amortecedor têm sido reconhecidos por muito tempo como um problema em línguas de baixo nível. O problema do núcleo é que a informação de controle do fluxo dos dados e do programa do usuário está misturada para a causa do desempenho, e as línguas de baixo nível permitem o acesso direto à memória da aplicação. C e C++ são as duas línguas as mais populares afflicted com overruns do amortecedor.

Estritamente falando, um overrun do amortecedor ocorre quando um programa permite que a entrada escreva além da extremidade do amortecedor alocado, mas há diversos problemas associados que têm frequentemente o mesmo efeito. Um do mais interessante é erros da corda do formato. Um outro incarnation do problema ocorre quando é permitido a um atacante escrever em uma posição de memória arbitrária fora de uma disposição na aplicação, e quando, falando estritamente, este isn’t um overrun clássico do amortecedor, nós’a tampa do ll que aqui demasiado.

O efeito de um overrun do amortecedor é qualquer coisa de um ruído elétrico ao atacante que ganha o controle completo da aplicação, e se a aplicação estiver funcionando como um usuário high-level (raiz, administrador, ou sistema local), a seguir o controle do sistema se operando inteiro e de todos os outros usuários que forem registrados atualmente sobre, ou entrará, está nas mãos do atacante. Se a aplicação na pergunta fosse um serviço de rede, o resultado da falha poderia ser um sem-fim. O primeiro sem-fim well-known do Internet explorou um amortecedor overrun no usuário do dedo, e foi sabido como o sem-fim do dedo de Robert T. Morris (ou Morris justo). Embora parecesse como se nós’d aprendemos como evitar overruns do amortecedor desde que um trazido quase para baixo o Internet em 1988, nós continua a ver relatórios freqüentes de overruns do amortecedor em muitos tipos de software.

Embora se possa pensar de que a somente rapina sloppy, descuidada da queda dos programadores ao amortecedor overruns, o problema é complexo, muitas das soluções não são simples, e qualquer um que escreveu bastante código de C/C++ fêz quase certamente este erro. Os programadores mesmo muito bons, muito cuidadosos fazem erros, e os programadores muito mais melhores sabem fácil deve deslizar acima e pôr práticas testando contínuas no lugar travar erros.

Línguas Afetadas

C é a língua a mais comum usada criar os overruns do amortecedor, seguidos pròxima por C++. Ele’s fácil de criar overruns do amortecedor quando escrever no ajuntador dado o não tiver nenhuma proteção em tudo. Embora C++ seja inerente tão perigoso quanto C, porque é um superset de C, usar a biblioteca padrão do molde (STL) com cuidado pode extremamente reduzir o potencial mishandle cordas. O strictness aumentado do compilador de C++ ajudará a um programador evitar alguns erros. Nosso conselho é que mesmo se você está escrevendo o código puro de C, usar o compilador de C++ resultará em um código mais limpo.

As línguas higher-level mais recentemente inventadas abstraem o acesso de memória direta afastado do programador, geralmente em um custo substancial do desempenho. As línguas tais como Java, C #, e básico visual têm tipos nativos da corda, disposições limit-verificadas, e proíbem geralmente o acesso de memória direta. Embora alguns dissessem que este faz overruns do amortecedor impossíveis, ele’s mais exato para dizer que os overruns do amortecedor são muito mais menos prováveis. Na realidade, a maioria destas línguas são executadas em C/C++, e as falhas da execução podem resultar em overruns do amortecedor. Uma outra fonte potencial de overruns do amortecedor no código higher-level existe porque o código deve finalmente conectarar com um sistema se operando, e esse sistema operando-se é escrito quase certamente em C/C++. C # permite-o de executar sem uma rede declarando seções inseguras; entretanto, quando fornecer um interoperability mais fácil com o sistema se operando e as bibliotecas subjacentes escritos em C/C++, você pode fazer os mesmos erros que você pode em C/C++. Se você programar primeiramente em línguas higher-level, o artigo de ação principal para você deve continuar a validar os dados passados às bibliotecas externas, ou você pode agir como a canalização a suas falhas.

Embora nós’re não ir fornecer uma lista exhaustive de línguas afetadas, a maioria de línguas mais velhas sejamos vulneráveis proteger overruns

O Sin Explicado

O incarnation clássico de um overrun do amortecedor é sabido como “despedaçar a pilha.” Em um programa compilado, a pilha é usada à informação de controle da preensão, tal como os argumentos, onde a aplicação necessita lhe retornar é feita uma vez com a função e por causa de the.small.number.of registos disponíveis nos processadores x86, completamente frequentemente os registos começam armazenados temporariamente na pilha. Infelizmente, as variáveis que são alocadas localmente são armazenadas também na pilha. Estas variáveis da pilha são consultadas às vezes inaccurately a como estaticamente sendo alocado, ao contrário de ser memória dinâmicamente alocada do heap. Se você ouvir alguém falar sobre um overrun do amortecedor de estática, o que significa realmente é um overrun do amortecedor da pilha. A raiz do problema é que se a aplicação escrever além dos limites de uma disposição alocada na pilha, o atacante começa especificar a informação de controle. E isto é crítico ao sucesso; o atacante quer modificar dados de controle aos valores de seu oferecer.

Se pôde perguntar porque nós continuamos a usar perigoso tão obviamente um sistema. Nós tivemos uma oportunidade de escapar do problema, ao menos na parte, com uma migração à microplaqueta’64-bit de Intel s Itanium, onde os endereços do retorno são armazenados em um registo. O problema é que nós’d temos que tolerar para trás uma perda significativa da compatibilidade, e como desta escrita, parece que a microplaqueta x64 terminará provavelmente acima da microplaqueta mais popular.

Você pode também perguntar porque nós don apenas’t que todos migram ao código que executa a disposição estrita que verifica e disallows o acesso de memória direta. O problema é aquele para muitos tipos de aplicações, as características de desempenho de línguas higher-level não é adequado. Uma terra média deve usar línguas higher-level para as relações top-level que interagem com as coisas perigosas (como usuários!), e línguas lower-level para o código do núcleo. Uma outra solução deve usar inteiramente as potencialidades de C++, e usa bibliotecas da corda e classes da coleção. Para o exemplo, o web server 6.0 do usuário de informação do Internet (IIS) comutado inteiramente a uma classe da corda de C++ para segurar a entrada, e um colaborador bravo reivindicou-o que’d amputa seu dedo pequeno se algum overruns do amortecedor for encontrado em seu código. Como desta escrita, o colaborador tem ainda seu dedo e nenhum boletim da segurança foi emitido de encontro ao web server nos quase dois anos desde sua liberação. Os compiladores modernos tratam bem de templatized classes, e é possível escrever o código muito high-performance de C++.

Bastante teoria—deixou’s considerar um exemplo:

# inclua < stdio.h >

anule DontDoThis(char * entrada)
{
char buf[16 ];

strcpy(buf, entrada);

printf("%s\n", buf);
}

argc do main(int, char internos * argv[ ])
{
//so nós não estamos verificando argumentos
//what você espera de um app que use strcpy?
DontDoThis(argv[1 ]);
retorno 0;
}

Deixe agora’s compilar a aplicação e fazer exame de um olhar em o que acontece. Para esta demonstração, o autor usou uma configuração da liberação com os símbolos eliminar erros permitidos e verificar da pilha incapacitado. Um compilador bom quererá também inline a uma função tão pequena quanto DontDoThis, especial se é chamado somente uma vez, assim ele incapacitou também optimizations. Aqui’s o que a pilha olha como em seu sistema imediatamente antes da chamada strcpy:

fe 12 de 0x0012FEC0 c8 00 Èþ. < - endereço do argumento do buf
0x0012FEC4 c4 18 32 00 Ä.2. < - endereço do argumento da entrada
0x0012FEC8 d0 fe 12 00 Ðþ. < - começo do buf
0x0012FECC 04 <<Unicode 80 40 00: 80>>@.
0x0012FED0 e7 02 3f 4f ç.?O
0x0012FED4 66 00 00 00 f... < - extremidade do buf
ä 00 do fe 12 de 0x0012FED8 e4þ. < - índices do registo de EBP
0x0012FEDC 3f 10 40 00?. @. < - endereço do retorno
0x0012FEE0 c4 18 32 00 Ä.2. < - endereço do argumento a DontDoThis
0x0012FEE4 c0 ff 12 00 Àÿ..
0x0012FEE8 10 13 40 00.. @. < - o main() do endereço retornará a

Recorde que todos os valores na pilha estão para trás. Este exemplo é de um sistema de Intel, que seja “pequeno-endian.” Isto significa que menos byte significativo de um valor vem primeiramente, assim que se você vê um endereço do retorno na memória como “3f104000,” ele’de s o endereço 0x0040103f realmente.

Deixe agora’s olhar o que acontece quando o buf overwritten. A primeira informação de controle na pilha é os índices do registo baixo prolongado do ponteiro (EBP). EBP contem o ponteiro do frame, e se fora--um pelo excesso acontecer, EBP será truncado. Se o atacante puder controlar a memória em 0x0012fe00 (fora--um por zero para fora do último byte), o programa salta a essa posição e executa o código atacante-fornecido.

Se o isn t’do overrun confinado a um byte, o artigo seguinte para ir for o endereço do retorno. Se o atacante puder controlar este valor, e puder colocar bastante conjunto em um amortecedor que conhece a posição de, você’re olhar um overrun exploitable clássico do amortecedor. Anote que o doesn t do código do conjunto (sabido frequentemente como o código do escudo porque a façanha a mais comum deve invocar um escudo do comando’) tem que ser colocado no amortecedor esse’s que overwritten.’S o caso clássico, mas no general, o código arbitrário que o atacante colocou em seu programa poderia ser encontrado em outra parte. Don’a tomada de t todo o conforto de pensar de que o overrun está confinado a uma área pequena.

Uma vez que o endereço do retorno overwritten, o atacante começa jogar com os argumentos da função exploitable. Se o programa escrever a alguns destes argumentos antes de retornar, representa uma oportunidade para o mayhem adicional. Este ponto torn-se-ar importante quando considerando a eficácia de contramedidas alterando da pilha tais como Crispin Cowan’s Stackguard, IBM’s ProPolice, e bandeira’do compilador de Microsoft s /GS.

Como você pode ver, nós’ve dado apenas o atacante ao menos três maneiras fazer exame do controle de nossa aplicação, e este estamos somente em uma função muito simples. Se uma classe de C++ com funções virtuais for declarada na pilha, a seguir a tabela virtual do ponteiro da função estará disponível, e esta pode fàcilmente conduzir às façanhas. Se um dos argumentos à função acontecer ser um ponteiro da função, que seja completamente comum em todo o sistema do windowing (para o exemplo, o sistema da janela de X ou o Microsoft Windows), então overwriting o ponteiro da função antes do uso é uma maneira óbvia desviar o controle da aplicação.

Muitos, muitas mais maneiras inteligentes apreender o controle de uma aplicação existem do que nossos cérebros feeble podem pensar de. Há um desequilíbrio entre nossas abilidades como colaboradores e as abilidades e recursos do atacante. Você’re não reservado uma quantidade de hora infinita de escrever sua aplicação, mas os atacantes não pode ter qualquer outra coisa a fazer com seu tempo de reposição copious do que a figura para fora de como fazer seu código faz o que quer. Seu código pode proteger um recurso esse’artigo de valor de s bastante para justificar meses do esforço subvert sua aplicação. Os atacantes gastam o tempo muito que aprendem sobre os desenvolvimentos os mais atrasados em causar o mayhem, e têm recursos como www.metasploit.com onde podem apontar e estalar sua maneira descascar o código que faz quase qualquer coisa eles quiserem quando se operando dentro de um jogo confinado do caráter.

Se você tentar determinar se algo é exploitable, é altamente provável que você o começará errado. Em a maioria de casos, é somente possível provar que algo é ou exploitable ou que você não é esperto bastante (ou para não ter gastado possivelmente bastante hora) determinar como escrever uma façanha. É extremamente raro poder provar com toda a confiança em tudo que um overrun não é exploitable.

O ponto deste diatribe é que a coisa esperta a fazer é reparar apenas os erros! Houve as épocas múltiplas que “codificam melhorias de qualidade” giraram para fora para ser reparos da segurança no retrospect. Este autor gastou apenas mais de três horas que discutem com uma equipe do desenvolvimento aproximadamente se ought reparar um erro. A linha do E-mail teve um total de oito povos nela, e nós gastamos fàcilmente 20 horas (uma metade um de pessoa-semana) que debatem se reparar o problema ou não porque a equipe do desenvolvimento quis a prova que o código era exploitable. Uma vez que os peritos da segurança provaram o erro era realmente um problema, o reparo foi estimado em uma hora do tempo do colaborador e das algumas horas do tempo do teste. Esse’s um desperdício de tempo incredible.

O um tempo quando você quer ser analítico é imediatamente antes de enviar uma aplicação. Se uma aplicação estiver nos estágios finais, você’d gosta de poder fazer uma suposição boa se o problema é exploitable justificar o risco das regressões e de destabilizing o produto.

’S um misconception comum que overruns em amortecedores do heap seja mais menos exploitable do que empilham os overruns, mas este gira para fora para não ser o caso. A maioria de execuções do heap sofrem da mesma falha básica que a pilha—os dados do usuário e os dados de controle é misturada. Dependendo da execução do allocator da memória, é frequentemente possível começar o gerente do heap colocar quatro bytes da escolha’do atacante s na posição especificada pelo atacante. Os detalhes de como atacar um heap são um tanto arcane. Uma apresentação recente e claramente escrita no tópico, “umas façanhas de confiança do heap de Windows” pelo shok “Conover” de Matthew & um Oded Horovitz, podem ser encontrados em http://cansecwest.com/ csw04/csw04-Oded+Connover.ppt. Mesmo se o gerente do heap não pode subverted para fazer um atacante’s que oferece, os dados nos alocamentos adjacentes podem conter ponteiros da função, ou ponteiros que serão usados escrever a informação. Em uma vez, explorando excessos do heap foi considerado exotic e os excessos—duros do heap são agora alguns dos tipos mais freqüentes de erros explorados.

Sinful C/C++

Há muitos, muitas maneiras overrun um amortecedor em C/C++. Aqui’s o que causou o sem-fim do dedo de Morris:

char buf[20 ];

gets(buf);

Não há absolutamente nenhuma maneira usar-se começa ler para input do stdin sem arriscar um excesso dos fgets—do uso do amortecedor preferivelmente. Talvez o segundo a maioria de maneira popular transbordar amortecedores deve usar strcpy (veja o exemplo precedente). Esta é uma outra maneira causar problemas:

char buf[20 ];
prefix[ do char ] = "HTTP://";

strcpy(buf, prefixo);
strncat(buf, trajeto, sizeof(buf));
Que foi erradamente? O problema aqui é que o strncat tem uma relação mal projetada. A função quer o número dos caráteres do amortecedor disponível, ou o espaço à esquerda, não o tamanho total do amortecedor do destino. Aqui’s uma outra maneira favorita causar excessos:

buf[MAX_PATH do char ];

sprintf(buf, "%s - %d\n", trajeto, errno);

Ele’s quase impossível, à exceção em alguns casos de canto, para usar com segurança o sprintf. Um boletim crítico da segurança para Microsoft Windows foi liberado porque o sprintf foi usado em uma função registrando eliminar erros. Consulte ao boletim MS04-011 para mais informação (veja a ligação “na outra seção” dos recursos).

Aqui’s um outro favorito:

char buf[32 ];
strncpy(buf, dados, strlen(data));
Assim que’erro de s com este? O último argumento está a um comprimento do amortecedor entrante, não o tamanho do amortecedor do destino!

Uma outra maneira causar problemas é confundindo a contagem de caráter pela contagem de byte. Se você’re tratar dos caráteres de ASCII, estes for o mesmo, mas se você’re tratar do Unicode, lá é dois bytes a um caráter. Aqui’s um exemplo:

_ snwprintf(wbuf, sizeof(wbuf), "%s\n", entrada);
O seguinte overrun é pouco um mais interessante:

bool contagem longa pInFile, não assinada de CopyStructs(InputFile *)
{
i longo não assinado;

m_pStructs = Structs[count novo ];

for(i = 0; i < contagem; i++)
{
if(!ReadFromFile(pInFile, &(m_pStructs[i ])))
ruptura;
}
}
Como pode esta falha? Considere que quando você chamar o operador do new[ de C++ ], é similar ao seguinte código:

ptr = malloc(sizeof(type) * contagem);
Se o usuário fornecer a contagem, ele o isn’t duramente para especificar um valor que transborde a operação da multiplicação internamente. Você’ll aloca então um amortecedor muito menor do que você necessidade, e o atacante pode escrever sobre seu amortecedor. O compilador upcoming de C++ no estúdio visual 2005 de Microsoft contem uma verificação interna para impedir este problema. O mesmo problema pode acontecer internamente em muitas execuções do calloc, que executa a mesma operação. Este é o crux de muitos erros do excesso do inteiro: Ele’s não o excesso do inteiro que causa o problema da segurança;’s o amortecedor overrun que segue rapidamente aquele causa os headaches. Mas mais sobre isto no sin 3.

Aqui’s uma outra maneira que um overrun do amortecedor pode começar criado:

# defina MAX_BUF 256
anule BadCode(char * entrada)
{
o short len;
buf[MAX_BUF do char ];

len = strlen(input);

curso de //of nós podemos usar strcpy com segurança
if(len < MAX_BUF)
strcpy(buf, entrada);
}
Isto olha como se ought trabalhar, direito? O código riddled realmente com problemas. Nós’ll começamos neste mais detalhadamente quando nós discutimos excessos do inteiro no sin 3, mas consideramos primeiramente que os literals são sempre do tipo interno assinado. Uma entrada mais por muito tempo do que 32K lançará len a um número negativo; começará o upcast a um interno e manterá o sinal; e agora é sempre menor do que MAX_BUF, causando um excesso. Uma segunda maneira você’problemas do encontro do ll é se a corda for maior do que 64K. Agora você tem um erro de truncamento: len será um número positivo pequeno. O reparo principal deve recordar que o size_t está definido na língua como o tipo correto para se usar para as variáveis que representam tamanhos pela especificação da língua. Um outro problema que’s que lurking é que a entrada não pode nulo-ser terminada. Aqui’s que código melhor olha como:

size_t do const MAX_BUF = 256;
LessBadCode(char vago * entrada)
{
o size_t len;
buf[MAX_BUF do char ];

len = strlen(input);

curso de //of nós podemos usar strcpy com segurança
if(len < MAX_BUF)
strcpy(buf, entrada);
}

Sins Relacionados

Um sin pròxima relacionado é excessos do inteiro. Se você escolher mitigate overruns do amortecedor usando a corda contada que segura chamadas, ou estiver tentando determinar quanto quarto alocar no heap, a aritmética se torna crítica à segurança da aplicação.

Os erros da corda do formato podem ser usados realizar o mesmo efeito que um overrun do amortecedor, mas aren’overruns de t verdadeiramente. Um erro da corda do formato é realizado normalmente sem overrunning nenhuns amortecedores em tudo.

Um variant em um overrun do amortecedor é um unbounded escreve a uma disposição. Se o atacante puder o fornecer o índice de sua disposição, e don’t validam corretamente se’s dentro dos limites corretos da disposição, alvejado escreve a uma posição de memória do atacante’escolher de s que será executado. Não somente pode toda a mesma diversão do fluxo de programa acontecer, mas também o atacante não pode ter que disrupt a memória adjacente, que hampers todas as contramedidas que você possa ter no lugar de encontro aos overruns do amortecedor.

Manchando o teste padrão do sin

Estão aqui os componentes a procurar:

  • Entrada, se lido da rede, uma lima, ou da linha de comando

  • Transferência dos dados de entrada dita às estruturas internas

  • Uso da corda insegura que segura chamadas

  • Uso da aritmética calcular um tamanho do alocamento ou tamanho de amortecedor restante

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

Manchar este sin durante a revisão de código varia de ser muito fácil a extremamente difícil. As coisas fáceis a procurar são uso da corda insegura que segura funções. Uma edição a estar ciente de é que você pode encontrar muitos exemplos do uso seguro, mas ele’s sido nossa experiência que há uns problemas que escondem entre as chamadas corretas. O código convertendo-se às chamadas seguras do uso somente tem uma taxa muito baixa da regressão (em qualquer lugar do 1/10th ao 1/100th do normal erro-repare a taxa da regressão), e removerá as façanhas de seu código.

Uma maneira boa fazer isto é deixou o compilador encontrar ligações de controle perigosas para você. Se você strcpy undefined, strcat, sprintf, e funções similares, o compilador encontrar todo para você. Um problema a estar ciente de é que alguns apps re-executaram toda a ou uma parcela biblioteca run-time de C internamente.

Uma tarefa mais difícil está procurando overruns do heap. Bàsicamente, você quer a primeiramente procura alocamentos, e examina então a aritmética usada calcular o tamanho de amortecedor.

A mais melhor aproximação total deve seguir o usuário input dos pontos de entrada de sua aplicação com todas as ligações de controle. Estando ciente de o que o atacante controla makes uma diferença grande

Técnicas testando para encontrar o sin

O fuzz que testa, que sujeita sua aplicação às entradas semi-random, é uma das técnicas testando melhores a usar-se. Tente aumentar o comprimento de cordas da entrada ao observar o comportamento do app. Algo olhar para fora para é que às vezes as mas combinações entre verificar da entrada resultarão em janelas relativamente pequenas do código vulnerável. Para o exemplo, alguém pôde pôr uma verificação em um lugar que a entrada deve ser menos de 260 caráteres, e aloca então um amortecedor de 256 byte. Se você testar uma entrada muito longa, estará rejeitada simplesmente, mas se você bater o excesso exatamente, você pode encontrar uma façanha. Os comprimentos que são múltiplos de dois e os múltiplos de dois mais ou menos um encontrarão frequentemente problemas.

Outros truques a tentar estão procurando todo o lugar na entrada onde o comprimento de algo é usuário especificado. Mude o comprimento de modo que não combine o comprimento da corda, e procure especial as condições das possibilidades do excesso—do inteiro onde o comprimento + 1 = 0 é frequentemente perigoso.

Algo que você deve fazer quando testar do fuzz dever criar uma configuração especializada do teste. Elimine erros de configurações têm frequentemente afirma esse fluxo de programa da mudança e mantê-lo-á de bater circunstâncias exploitable. Na outra mão, elimine erros de configurações em compiladores modernos contêm tipicamente uma deteção mais avançada do corruption da pilha. Dependendo de seus heap e sistema operando-se, você pode também permitir verificar mais estrito do corruption do heap.

Uma mudança que você pode querer fazer em seu código é que se afirmar estiver verificando a entrada do usuário, mude o seguinte de

assert(len < MAX_PATH);

a

if(len > = MAX_PATH)
{
assert(false);
falso do retorno;
}

Você deve sempre testar seu código sob algum formulário da ferramenta da deteção de erro da memória, tal como AppVerifier em Windows

Sins Do Exemplo

As seguintes entradas, que vêm diretamente dos vulnerabilities comuns e as exposições alistam, ou CVE (http://cve.mitre.org), são exemplos de overruns do amortecedor. Um bocado interessante do trivia é que como desta escrita, 1.734 entradas de CVE que o overrun “do amortecedor do fósforo” existe. Uma busca dos advisories do CERT, que documentam somente os vulnerabilities mais difundidos e mais sérios, rende 107 batidas “no overrun do amortecedor.”

CVE-1999-0042

Da descrição de CVE: “Proteja o excesso na universidade da execução’de Washington s do IMAP e ESTALE usuários.“

Esta entrada de CVE é documentada completamente em CERT CA-1997-09 consultivo, e envolveu um overrun do amortecedor na seqüência do authentication da universidade de usuários’do protocolo de acesso de mensagem do Post Office Protocol (PNF) e de Internet de Washington s (IMAP). Um vulnerability relacionado era que o usuário do E-mail não executou menos privilégio, e a façanha concedeu o acesso da raiz aos atacantes. O excesso conduziu a exploração difundida de sistemas vulneráveis.

As verificações do vulnerability da rede projetaram encontrar versões vulneráveis deste usuário encontraram falhas similares em laboratórios SLMail 2.5 de Seattle como relatado em www.winnetmag.com/Article/ArticleID/9223/9223.html.

CVE-2000-0389–CVE-2000-0392

De CVE-2000-0389: “O excesso do amortecedor na função do krb_rd_req em Kerberos 4 e 5 permite que os atacantes remotos ganhem privilégios da raiz.”

De CVE-2000-0390: “O excesso do amortecedor na função de krb425_conv_principal em Kerberos 5 permite que os atacantes remotos ganhem privilégios da raiz.“

De CVE-2000-0391: “O excesso do amortecedor no krshd em Kerberos 5 permite que os atacantes remotos ganhem privilégios da raiz.“

De CVE-2000-0392: “O excesso do amortecedor no ksu em Kerberos 5 permite que os usuários locais ganhem privilégios da raiz.“

Esta série dos problemas na execução do MIT do Kerberos é documentada como CERT CA-2000-06 consultivo, encontrou em www.cert.org/advisories/CA-2000-06.html. Embora o código de fonte estivesse disponível ao público por diversos anos, e o problema stemmed do uso da corda perigosa que segura funções (strcat), relatou-se somente em 2000.

CVE-2002-0842, CVE-2003-0095, CAN-2003-0096

De CVE-2002-0842:

O vulnerability da corda do formato em determinadas modificações third-party ao mod_dav para registrar mensagens más da passagem (por exemplo, usuário 9.0.2 da aplicação de Oracle9i) permite os atacantes remotos executem o código arbitrário através de um destino URI que force “uma resposta da passagem do bad” 502, que faça com que os specifiers da corda do formato sejam retornados do dav_lookup_uri() em mod_dav.c, que é usado então em uma chamada ao ap_log_rerror().

De CVE-2003-0095:

Proteja o excesso em ORACLE.EXE para o usuário 9i da base de dados do oracle, 8i, 8.1.7, e 8.0.6 permitem que os atacantes remotos executem o código arbitrário através de um username longo que seja fornecido durante o início de uma sessão como as aplicações diretas exploitable do cliente que executam seu próprio authentication, como LOADPSP se usando demonstrado.

De CAN-2003-0096:

Os excessos múltiplos do amortecedor na liberação 2 da base de dados do oracle 9i, na liberação 1, no 8i, em 8.1.7, e em 8.0.6 permitem que os atacantes remotos executem o código arbitrário através (1) de um argumento longo da corda da conversão à função de TO_TIMESTAMP_TZ, (2) um argumento longo da zona de tempo à função de TZ_OFFSET, ou (3) um parâmetro longo do DIRETÓRIO à função de BFILENAME.

Estes vulnerabilities são documentados em CERT CA-2003-05 consultivo, situado em www.cert.org/advisories/CA-2003-05.html. Os problemas são um jogo de diversos encontrados por David Litchfield e sua equipe software Ltd da segurança da geração seguinte. Como um aparte, isto demonstra aquele que anuncia uma’aplicação de s porque “unbreakable” não pode ser a mais melhor coisa a fazer whilst o Sr. Litchfield está investigando suas aplicações.

CAN-2003-0352

Da descrição de CVE:

Proteja o excesso em uma determinada relação de DCOM para o RPC em NT 4.0 de Microsoft Windows, 2000, XP, e o usuário 2003 permite que os atacantes remotos executem o código arbitrário através de uma mensagem malformed, como explorado pelos sem-fins de Blaster/MSblast/ LovSAN e de Nachi/ Welchia.

Este excesso é interessante porque conduziu a exploração difundida por dois sem-fins muito destrutivos esses que ambos causaram o rompimento significativo no Internet. O excesso estava no heap, e foi evidenciado pelo fato que era possível construir um sem-fim que fosse muito estável. Um fator contribuindo era uma falha do princípio de menos privilégio: a relação não deve ter estado disponível aos usuários anonymous. Uma outra nota interessante é que as contramedidas do excesso em Windows 2003 degradaram o ataque do escalation do privilégio à negação de serviço.

Mais informação neste problema pode ser encontrada em www.cert.org/advisories/ CA-2003-23.html, e em www.microsoft.com/technet/security/bulletin/MS03-039.asp

Etapas Do Redemption

A estrada para proteger o redemption do overrun é longa e enchida com os potholes. Nós discutimos uma variedade larga das técnicas que lhe ajudam evitar overruns do amortecedor, e um número outras de técnicas que se reduzem os overruns do amortecedor dos danos podem causar. Deixe’s olhar como você pode melhorar seu código.

Substitua A Corda Perigosa Que Segura Funções

Você deve, no mínimo, substituir funções inseguras como strcpy, strcat, e sprintf com as versões contadas de cada uma destas funções. Você tem um número de escolhas de o que para substitui-lo com. Mantenha na mente que umas funções contadas mais velhas têm problemas da relação, e pedem que você faça a aritmética em muitos casos para determinar parâmetros. Os computadores aren’t tão bom no math como você pôde esperar. Umas bibliotecas mais novas gostam do strsafe, do CRT seguro (biblioteca run-time de C) que será enviado no estúdio visual de Microsoft (e está em uma trilha rápida a se tornar a parte do padrão do ANSI C/C++), e de strlcat/strlcpy para * nix. Você necessita também tomar cuidado com como cada uma destas funções segura a terminação e o truncamento das cordas. Algumas funções garantem a terminação nula, mas mais das funções contadas mais velhas não . A experiência do grupo s’do escritório de Microsoft com substituir a corda insegura que segura funções para a liberação do escritório 2003 era que a taxa da regressão (erros novos causados por o reparo) era extremamente baixa, assim que don’t deixou o medo do batente das regressões você.

Alocamentos Do Exame

Uma outra fonte de overruns do amortecedor vem dos erros aritméticos.

Verifique laços e ponha acessos

Uma terceira maneira que o amortecedor overruns é causada não está verificando corretamente a terminação nos laços, e não corretamente verificando limites de disposição antes de escreva o acesso. Esta é uma das áreas as mais difíceis, e você encontrará que, em alguns casos, o problema e terra-se quebrar-kaboom estão nos módulos completamente diferentes.

Substitua amortecedores da corda de C com as cordas de C++

Isto é mais eficaz do que apenas substituindo as chamadas usuais de C, mas pode causar quantidades tremendas de mudança em código existente, particularmente se o isn t’do código compilado já como C++. Você deve também estar ciente de e compreender as características de desempenho das classes do recipiente de STL. É muito possível escrever o código high-performance de STL, mas como muitos outros aspectos da programação, uma falha ler o manual fino (RTFM) resultará frequentemente em resultados menos do que optimal. A recolocação a mais comum deve usar as classes do molde de STL std::string ou de std:wstring.

Substitua disposições de estática com os recipientes de STL

Todos os problemas notáveis acima se aplicam aos recipientes de STL como o vetor, mas um problema adicional é que não todas as execuções da construção de vector::iterator verificam para ver se há fora do acesso de limites. Esta medida pode ajudar, e o autor encontra aquele usar o STL faz possível para que escreva o código correto mais rapidamente, mas esteja ciente que este isn’t uma bala de prata.

Use Ferramentas Da Análise

Há algumas ferramentas boas que vêm no mercado que analisam o código de C/C++ para defeitos da segurança; os exemplos incluem Coverity, PREfast, e Klocwork. O NET visual 2005 do estúdio incluirá PREfast e uma outra ferramenta chamados língua da anotação do código de fonte (SAL) para ajudar seguir para baixo defeitos da segurança tais como overruns do amortecedor. A mais melhor maneira descrever o SAL é por o código.

No exemplo (silly) que segue, você sabe o relacionamento entre os dados e os argumentos da contagem: os dados são bytes da contagem longos. Mas o doesn t’do compilador sabe; vê apenas um char * e um size_t.

vácuo * DoStuff(char * dados, contagem do size_t) {
char de estática buf[32 ];
memcpy(buf, dados, contagem do retorno);
}

Este código olha APROVADO (ignorando o fato nós amortecedores de estática de retorno loath, mas humor nos). Entretanto, se a contagem for maior que 32, a seguir você tem um overrun do amortecedor. Uma versão anotada SAL desta travaria o erro:

vácuo * char de DoStuff(__in_ecount(count) * dados, contagem do size_t) {
char de estática buf[32 ];
memcpy(buf, dados, contagem do retorno);
}
Isto é porque o compilador e/ou o PREfast sabem agora que os dados e a contagem estão relacionados firmemente.

Medidas Defensivas Extra

Considere medidas adicionais do defensive a mesma maneira que você pensa de correias de assento em seu carro. As correias de assento reduzirão frequentemente a severidade de um ruído elétrico, mas você ainda não quer começar em um acidente.’S importante anotar que para cada classe principal do amortecedor overrun o mitigation, as circunstâncias previamente exploitable que são umas exploitable não mais longo em tudo existe; e para toda a técnica dada do mitigation, um ataque suficientemente complexo pode superar a técnica completamente. Deixe’s olhar alguma deles.

Empilhe A Proteção

A proteção da pilha foi aberta caminho por Crispin Cowan em seu produto de Stackguard, e executada independentemente por Microsoft como o interruptor do compilador de /GS. No seu mais básico, empilhe lugares da proteção um valor sabido como um canário na pilha entre as variáveis locais e o endereço do retorno. Umas execuções mais novas podem também requisitar novamente variáveis para a eficácia aumentada. A vantagem desta aproximação é que é barata, tem despesas gerais mínimas do desempenho, e tem o benefício adicional de fazer erros do corruption da pilha eliminar erros mais fáceis. Um outro exemplo é ProPolice, uma extensão da coleção do compilador do gnu (GCC) criada por IBM. Todo o produto atual deve utilizar a proteção da pilha.

Você deve estar ciente que a proteção da pilha pode ser superada por uma variedade das técnicas. Se uma tabela virtual do ponteiro da função overwritten e a função está chamada antes do retorno da função que—os destructors virtuais são candidatos bons—então a façanha ocorrerá antes que a proteção da pilha possa vir no jogo.

Pilha e heap non-executable

Este as contramedidas oferecem a proteção considerável de encontro a um atacante, mas pode ter um impacto significativo da compatibilidade da aplicação. Algumas aplicações legitimately compilam e executam o código na mosca, tal como muitas aplicações escritas em Java e em C #. ele’s também importante anotar que se o atacante puder fazer com que sua aplicação caia rapina a um retorno no ataque do libc, onde uma ligação de controle legitimate está feita para realizar extremidades nefarious, a seguir a proteção executar na página da memória pode ser removida.

Infelizmente, a maioria da ferragem atualmente disponível é incapaz de suportar esta opção, e a sustentação varia com CPU-type, sistema operando-se, e versão do sistema operando-se também. Em conseqüência, você não pode contar nesta proteção que está atual no campo, mas você deve testar com ele permitiu de assegurar-se de que sua aplicação seja compatível com uma pilha e um heap non-executable, funcionando sua aplicação na ferragem que suporta a proteção da ferragem, e o sistema se operando do alvo ajustado para usar a proteção. Para o exemplo, se você estiver alvejando Windows.xp, a seguir certifique-se que você funciona todos seus testes em um computador de Windows.xp SP2 usando um processador de AMD Athlon 64 FX. Em Windows, esta tecnologia é chamada a proteção de Dados Execução (DEP); soube-se uma vez como o nenhum executa (NX).

O usuário 2003 SP1 de Windows suporta também esta potencialidade. Os PaX para Linux e OpenBSD suportam também a memória non-executable

Outros Recursos

este é um artigo adicionado por Hendra Fang


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