Identifying Bad Characters
Last updated
Last updated
Antes de começarmos a utilizar o fato de que podemos controlar EIPe subverter o fluxo de execução do programa, precisamos determinar quaisquer caracteres que devemos evitar usar em nossa carga útil.
Como estamos atacando um parâmetro de entrada (neste caso, um arquivo aberto), espera-se que o programa processe nossa entrada. Portanto, dependendo do processamento que cada programa executa em nossa entrada, certos caracteres podem informar ao programa que ele atingiu o final da entrada. Isso pode acontecer mesmo que ainda não tenha chegado ao final da entrada.
Para identificar caracteres inválidos, temos que enviar todos os caracteres após preencher o EIPendereço, que fica após 4112+ 4bytes. Em seguida, verificamos se algum dos caracteres foi removido pelo programa ou se nossa entrada foi truncada prematuramente após um caractere específico.
Para fazer isso, precisaríamos de dois arquivos:
Um .wavarquivo com todos os caracteres para carregar no programa
Um .binarquivo para comparar com nossa entrada na memória
Podemos usar ERCpara gerar o .binarquivo e gerar uma lista de todos os personagens para criar nosso .wavarquivo. Para fazer isso, podemos usar o ERC --bytearraycomando:
Isso também cria dois arquivos em nossa área de trabalho:
ByteArray_1.txt: Que contém a string de todos os caracteres que podemos usar em nosso exploit python
ByteArray_1.bin: Que podemos usar ERCmais tarde para comparar com nossa entrada na memória
O próximo passo seria gerar um .wavarquivo com a sequência de caracteres gerada por ERC. Mais uma vez escreveremos uma nova função bad_chars()e usaremos um código semelhante à função eip_control(), mas usaremos os caracteres em C# de ByteArray_1.txt. Criaremos uma nova lista de bytes all_chars = bytes([])e colaremos os caracteres entre colchetes. Em seguida, escreveremos no chars.wavmesmo payload em eip_control()e adicionaremos depois dele all_chars. A função final ficaria assim:
Agora podemos executar nosso exploit F5para gerar o chars.wavarquivo.
Agora podemos reiniciar nosso programa x32dbge carregá chars.wav-lo. Feito isso, podemos começar a comparar nossa entrada na memória e ver se algum caractere está faltando. Para fazer isso, podemos verificar o painel Stack no canto inferior direito de x32dbg, que deve estar alinhado exatamente no início da nossa entrada:
Agora podemos percorrer manualmente a pilha, linha por linha, da direita para a esquerda e garantir que todos os valores hexadecimais estejam presentes, de 0x00até 0xff. Como isso pode demorar um pouco e dependeríamos inteiramente de nossos olhos, podemos perder um ou dois personagens. Portanto, utilizaremos mais uma vez ERCpara fazer a comparação para nós. Ele comparará facilmente nossa entrada na memória com todos os caracteres.
Devemos primeiro copiar o endereço de, ESPpois é aqui que nossa entrada está localizada. Podemos fazer isso clicando com o botão direito sobre ele e selecionando Copy valueou clicando em [Ctrl + C]:
Assim que tivermos o valor de ESP, podemos usar ERC --comparee fornecer o ESPendereço e a localização do .binarquivo que contém todos os caracteres, da seguinte forma:
O que este comando fará é comparar byte a byte nossa entrada ESPe todos os caracteres que geramos anteriormente em ByteArray_1.bin:
Como podemos ver, isso coloca cada byte de ambos os locais próximos um do outro para detectar rapidamente quaisquer problemas. A saída que buscamos é onde todos os bytes de ambos os locais são iguais, sem qualquer diferença. No entanto, vemos que após o primeiro caractere, 00todos os bytes restantes são diferentes.This indicates that 0x00 truncated the remaining input, and hence it should be considered a bad character.
Agora que identificamos o primeiro caractere inválido, devemos usar --bytearraynovamente para gerar uma lista de todos os caracteres sem os caracteres inválidos, que podemos especificar com -bytes 0x00,0x0a,0x0d...etc.. Então, usaremos o seguinte comando:
Agora, vamos usar este comando novamente ERCpara gerar o novo arquivo e usá-lo para atualizar nosso exploit:
Como podemos ver, desta vez, disse excluding: 00, e a tabela de array não inclui 00no início. Então, vamos ao arquivo de saída gerado ByteArray_2.txt, copie os novos bytes em C#e coloque-os em nosso exploit, que agora deve ficar assim:
Assim que tivermos nosso novo chars.wavarquivo, iremos carregá-lo novamente em nosso programa e usá-lo --comparecom o novo ByteArray_2.binarquivo para ver se ambas as entradas correspondem:
Como podemos ver, desta vez, ambas as linhas correspondem perfeitamente até 0xFF, o que significa que não há mais caracteres ruins em nossa entrada. Se tivéssemos identificado outro personagem ruim, repetiríamos o mesmo processo que acabamos de fazer Eliminating Bad Charactersaté que ambas as linhas correspondam perfeitamente.
Então, agora sabemos que devemos evitar usar 0x00no EIPendereço que queremos executar ou no nosso shellcode.
