1

Eh com imensa satisfacao que dou inicio a mais um deleitoso, conciso e eloquente paper, focando sempre a primazia do nosso povo. Dessa vez descrevo o poder do Heap Spraying em suas diversas rotacoes por assim dizer, bem como demostrando todo o processo de escrita dos e ploits se utilizando de uma didatica bastante e planatoria! muito bem elucidaria, diria. "lgumas pessoas escrevem e ploits de Heap Spraying se utilizando de varias linguagens que n#o a utilizada ao longo deste documento, que de fato se trata de uma linguagem de marcacao de te to, e n#o de programacao propriamente dita. $ao resta duvida alguma de que %a meu ver& a linguagem mais versatil para a escrita de e ploits de HS ' (avaScript. "o inves de codarmos rotinas de torpe compreensao %vbscript e "ctionScript por e emplo& por parte dos nossos discipulos do mau a.).a Script *iddies %que estao a uma passada atras de nos, os hac)us lindoes do lado negro ".).a +lac) Hats&, simplesmente utilizaremos tags em html para escrever nossas armas de e ploitacao, se por algum acaso do destino nosso sabadado estah sendo uma droga. Dedico como sempre o paper ao amigo Wallace Ferreira ".).a Dark_Side %que n#o tenho noticias a um pouco mais de um ano&, Fernando Birck ".).a F3rGO %que ' indubitavelmente um ,not-rio, conhecedor de engenharia reversa&, AciDmuD por ter dei ado um coment.rio bunitim no meu perfil lah que eu posto photos %" ur/0 12&, assim me dando e consequentemente a toda minha prole os direitos da magazine. "o 3ilipe +alestra ".).a 4oidelo)o por ter sugerido uma palestra minha pra H5H4 onde o +SDaemon e o $ash 6eon cantam de galo a anos, fato esse que culminou na escrita desse paper 7cu8o o 9nico ponto falho era de n#o pagar direitinho meu honorarios7. 4orelanc/d:r ;"th4on<, aos meus vizinhos e especialmente pra voc=, >u. 2or ultimo e n#o menos importante %o clich= nosso de cada dia&, Jeremy Brown ".).a Rush por sempre estar prontamente apto a me enviar todos os seus ne?est fuzzers e por ser um bom brasileiro! e a todos que se empenham horas por dia diante de seu 24 com a 9nica e quase e clusiva pretencao de enaltecer o hac)ing brasileiro e o (ames +ond. @ambem gostaria de enfatizarAresvalarAressaltar minha indignacao contra os fabricantes de salsicha tintera, pois um dia desses estava eu 8ogando o nosso bom e velho *ingdom Hearts B 4hain of memories %cough us up monstroC&, de cueca, quando me deparo com a mesma toda manchadaC Dbrigado pela atenE#o.$ao podemos esquecer a senhorita Sandra Julia Firmino %,")a Little Witch& por gostar tanto de nes)ui) de morango e dos bunequinho do 3inal 3antasy >FFF for ps:. E ao EduAadmin do blac)hatBforums por ser mais um brasileiro )tando e ploits para nosso governo e por ter codado uma html bac)door, bem como entender a fundo o 2a> pr/8:ct G1&

At the beginning Summary/Prologue

D nosso playground aqui serah sobre a arquitetura do tio +ill, porque de fato n#o vivo sem os HHDI2Js, mesmo com o Kine e o LH?areB?or)stationBM././BNNN5M.i:OM.tar.gz a solta por aih. D foco aqui serah o K:5 OM >2BS2: rodando Fnternet E plorer M./.5P//.00Q5. psp./O/NQ:B5QQQ. 4omo usual rode seu bro?er e ao lado da guia Ferramentas faEa o que estah vendo abai o para descobrir a versao de seu bro?ser.

2ra )tar o seu pacote de servico basta que emita o comando ?inver na shell ou em ,E ecutar,, se teu DS estiver em portugu=s.

Eh de conhecimento geral que havia no mil?/rm um montante significativo de e ploits remotos concernente a tecnica que voc= estarah perfeitamente apto a lidar ap-s a leitura deste documento. Entretanto uma quantidade consideravel desse montante foi codado para FER e versoes anteriores, como a que e ploraremos ao longo do paper, ou se8a, era facil analisar a estrutura dos e ploits para saber como a falha ocorria e saber como escrever os e ploits HS. 2orque ressaltei esse fatoS

2elo simples fato de Heap Spraying precisar de certos a8ustes para ser e ploitado sobre FEO %o padrao do Kindo?sR&. Loce teoricamente 2i a a Heap, mas nada parece ter acontecido. 4ontudo espero que aguardem um pouco mais, logo ap-s a H5H4 desse ano escreverei uma continuaE#o para esse documento. Has se mesmo assim n#o quiser esperar basta que analise um modulo do metasploit para HSQQT/0/ que foi codado por um cara chamado sinn:r, no qual e plora o FEO rodando debai o de DE2 7bosta7, sobre Kindo?s R e %claro&, tambem %se retirarmos uma coisa aqui e alih& e plora o nosso bom e velho Kindo?s >2 dos usuarios comuns G1& LinganEa por terem retirado o nosso idolatrado Ia? Soc)et do >2 Service 2ac) Q. HanditosC 4omo n#o tenho tanta disponibilidade de tempo assim, por hora, fico devendo, mas a 9nica coisa que a DE2 faz ' impedir o salte para os $D2s na heap, nada alem };) Entao, assumiremos aqui que a nossa amiga DE2 n#o estah habilitada %o padrao para todos os >2s&. Lale ressaltar que, a e ploracao sobre FEP ' diferente da e ploracao do FE Q/ sobre ?indo?s O. 2rimeiramente pegue o embasamento contido nesse documento e espere o documento sequente, mas se n#o tiver paciencia pode 8. ir procurando informacoes sobre uma palestra feita para a +lac)Hat por "le ander Sotirov a cerca de uma tecnica intitulada Heap 3eng Shui. Entao, e iste um pacote chamado FE4ollections que disponibiliza como o pr-prio nome 8. da a entender uma coleE#o de FEs <2 4om esse pacote voce pode upgradear seu FEO por um FEP, depois retirar o EFP para voltar a ter o padrao do Kindo?sR, o FEO. Eh o mesmo esquema com o FEM e FER, lembrando que os dois podem ser e plorados facilmente com base nas infomacoes que aqui estao contidas, e que sem duvida, ' uma otima base para voc= se calcar para dar inicio a escrita de e ploits para os outros releases do FE e consequentemente estar mais do que habilitado a escrever e ploits para outros bro?sers usando Heap Spraying, como o firefo que ' um dos bro?sers que mais preponderam no mercado dos usuario leigos %talvez porque se8a mais bonitinho&. 2ara dar prosseguimento ao paper voce tambem precisarah do Fmmunity Debugger %nada contra o Dlly do 3:rJD& e de uma ferramenta incrivel chama mona, a tia do mau :) white hat p.a.u.-no-cuh

Alocacao de dados na heap

(avaScript aloca a maior parte de sua memoria com HSL4I@ malloc%& e funcoes ne?%&, ponto. "penas tenha isso em mente, por hora. " e ceE#o da regra ' 8ustamente concernente as strings, no qual faremos uso para pi ar a heap com o intuito de fazermos o retorno do SEH e ploiting %nesse caso em especial& saltar para os $D2s na mesma e consequentemente alcanEar o shellcode.

"s Strings em (S por sua vez s#o armazenadas como string +S@I, que nada mais ' do que um tipo de string basico e possui um header %no qual veremos logo mais abai o&. " memoria para strings 8avascript ' alocada se utilizando da famUlia de funcoes Sys"llocString contidas na "2F V?indo?sVsystem:5Voleaut:5.dll, no qual tambem contem %as& funcoes +S@ITWser3ree, Harshal, Size e WnHarshal. 4erto, vamos ver o que ' isso na pratica. ;allocation.htm<

2ronto, dados alocados na Heap do processo %modulo ie plore&. Loce poderah declarar variaveis de varias formas para alocaBlas na memoria do programa, pode por e emplo se utilizar do Db8eto String B ne? String%str&!, declarar a variavel seguida de uma outra com o ,X, e pode usar tambem substring%count, count5&!, com esse mesmo proposito. Le8a e emplos mais e planatorios.
var variavel = new String("undigrud"); // aloca na heap a string "undigrud" var variavel = variavel0 variavel2; // concatena !unto ao "inal de variavel0

substring(counter, counter )!
3az a e tracao de parte de uma string .

Sinta e.Y
string = "Fiu Fiu"; document.write(string.substring(0,3)); // resultado# $iu

%ropriedade length
Wsada para determinar a quantidade de caracteres de uma string.

Sinta e.Y
string = "whitehat"; document.write(string.length + ' characters long'); &

D principal foco deste documento n#o ' 8avascript, mas sim Heap Spraying, por isso n#o vou dar prosseguimento a isso, desculpe. 4laro que e iste muita material 8. publicado sobre (avascript tanto em video quanto em te to, na internet. Sucintamente escreva Curso de JavaScript 8unto ao altavista que voc= encontrarah muita informacao publica de qualidade. 4erto, string alocada na memoria, vamos v=BlaS E ecute o Fmmunity enquanto a pagina estiver rodando e ate o processo ao mesmo.

'

3aremos uso agora de uma ferramenta obscura e pesada chamada mona v1.8x %meu release! e o mais recente no momento dessa escrita&. 3erramenta essa largamente usada por muitos manohs do under, talvez por ser poderosa e precisa. 2ara sanar alguma duvida a cerca de qualquer comando do mona simplesmente escreva na 8anela de comandos do Fmmunity %logo abai o da 8anela principal, no canto esquerdo&.

Du simplesmente Cmona help para obter uma listagem de todos os comandos disponibilizados no release Q.O. 2ara instalar o mona basta que voc= movaBo %mona.py& para o diretorio de armazenagem de comandosAscripts do FmmunityY

D que faremos agora eh procurar na memoria I"H a nossa string previamente alocada, string essa alocada na heap atraves do uso de 8avascript.

" comando #ind

4omo voc= pode observar %ap-s escrever Cmona help find na 8anela de comandos do Fmmunity& o comando acha uma sequencia de bytes em memoria. "lgumas ressalvas devem ser feitas agora, a primeira delas ' que a opcao Bs ' mandatoria seguida do patternAstring propriamente dito, a segunda ' que o intervalo de memoria / //////// to / Rfffffff corresponds a toda a memoria, intervalo esse setado com base %Bb& e topo %Bt&. Bunicode ou Bascii faz buscas por toda a memoria tento como ponto de partida / //////// to / Rfffffff %arquitetura de :5 bits& a procura da string em ascii ou unicode. B Fh fudeu. Loce fala. Iela a, o paper nem comecou ainda.

Esse comando fala pro mona achar %find& a string %Bs& undigrud que estah em Bunicode partindo do endereco base / //////// ao endereco topo / Rfffffff %que corresponde a toda memoria destinada a esse processo&. (unto a 8anela de log % & voc= poderah verificar os resultados desse comando .

4omo voc= pode nitidamente observar ele realmente fez o que queriamos que ele fizesse. Encontrou Q: ponteiros para a nossa string, ou se8a, ocorrencias que apontam para a mesma. Le8a alih a linha earching !rom 0"00000000 to 0"#!!!!!!! %pesquisando de / ////... a / Rf...&. Dbserve que ele ainda escreve os resultados em um arquivo de log %find.t t& no diretorio Immunity Debugger. "gora esse aqui ' pro LooDoo. 3aremos uma breve analise do bac)trace desse arquivo de log s- por curiosidade irmaos de chapeu G;) Dentre as informacoes contidas nesse arquivo de log voc= podera verificar a versao da biblioteca, os modulos propriamente dito e o caminha no qual eles se encontram no sistema.

Esses s#o alguns modulos que s#o carregados na memoria em tempo de e ecucao. Lale salientar novamente que o termo ,modulo, nada mais ' do que o termo usado para designar os arquivos carregados na memoria, como por e emplo .e es ou .dlls. Dbserve abai o esses dois modulos. (ah invadi muita maquina por Heap Dverflo? e plorando o "S$Q 6ibrary. Loce verificarah abai o que foi carregado pra memoria tambem a HSL4I@, lembra do malloc%&S E... Dlha que lindo esse bac)trace %achamos a nossa boa e velha HS"S$Q&Y

4ompreende agora o porque da enfase nos modulos acimaS Essas "2Fs podem ser facilmente fuzzadas usando frame?or)s como o 4omraider da idefense labs %ferramenta muito poderosa&. @ambem enfatizei as "2Fs padroes para lembrarBlhes que voc= tambem pode achar retorno nelas para escrever e ploits de buffer overflo? classico. +em, ve8amos o que mais foi carregado para a memoria alem de msvcrt ;)

Loce estah entendendo onde eu quero chegar...

Loltaremos a nossa velha log ?indo? para continuar a analise dos logs do nosso searching for.

D mona estah nos falando que, o endereco de memoria //:N+5+4 %/ //:Nb5bc& realmente guarda a nossa string e que se trata de uma string %unicode&. D pretenso hac)er astuto tambem notarah logo a direita a palavra ;Heap<, s- por desencargo de consci=ncia analisaremos o dump da ocorrencia. Duplo clique no segundo ponteiro por favor. " que aponta para o endereco de memoriaY "pos isso somos instantaneamente direcionados para a 8anela principal, 42W. Dbserve no canto inferior esquerdo da main ?indo? o seguinte resultado.

Le8a abai o de ASCII a nossa string. 4omo sempre gosto de repetir em uma grande parte de meus te tos, dois digitos em he adecimal equivalem a Q byte, e nesse caso esses dois digitos abai o de Hex dump equivalem a uma letra %representada abai o de "S4FF&, mas... mas observe atentamente que e iste um // ap-s cada letra da string, que abai o de "S4FF equivale a um ponto. Hum... Fsso ' o que caracteriza uma string unicode no dumping. Lamos com calma. Le8a nossa string alih, //:N+5+4 armazena a letra R0 %u&. 4omo todos sabemos o enderecamento de base he adecimal segue o modelo partindo de / a 3 e ao inves de ,P, Q/, serah ,P, ",, ateh 3, depois os digitos comecao a se repetir e o endereco ad8acente a esse ' incrementado. 2egouS $aoS @a achando que eu to te sacaneandoS D endereco de memoria //:N+5+D sua vez armazena o // e o //:N+5+E armazena o n %ME&. Lamos ver na pratica manohC Wse o comando ,d, do Fmmunity, ele faz um dumping de um endereco quaquer, ou se8a, mostraBnos o que esta armazenado por lah. Escreve ,d //:N+5+D, e ,d //:N+5+E, na 8anela de comandos do Fmmunity e em seguida tecle ;Enter<

E ato e perfeito. Entao podemos inferir que o seguinte mapa de memoria ' realmente valido.

10

"cabei de escrever um pequeno coide aqui que converte "S4FF strings em Wnicode strings %a que costumeiramente vemos nos dumpings de Heap Spraying. Loc= saberah o porque adiante&. Lale salientar que a 9nica distincao entre ambas no dumping ' apenas o //, ou se8a, os digitos em he adecimal usados para representacao das letras do alfabeto ainda continuam sendo os mesmos para ambos os caracteres de te to, e isso quer dizer que a ferramenta abai o serah n#o s- de grande valia como de suma importZncia para conversao de "S4FF em He . Lale ressaltar tambem o fato de ser de conhecimento pulico que as Wnicode strings equivalem dois bytes. Do ya )no? ?hyS "cho que agora voc= sabe o porque ;)

$include %stdio.h& main ()' int i=0; char str()*+, c; ,rint! ("-lessandra . - /00 to 1nicode utilit2 b2 345l6c784!0"39n9 :i,er /or,. *003.*0)*9n9n;2,e some he" digits< "); scan! ("=s", >str); for (i;i% strlen(str);++i)' c=str(i+; ,rint! ("=" 00 ", c); } }

Lale ressaltar o fato de que strings no dumping s#o case sensitive, ou se8a, e iste uma distinE#o entre as letras mai9sculas e minusculas %upper e lo?ercase respectivamente& .

11

3alamos muito ateh aqui a cerca desse tal de unicode. Do que realmente se trataS Segundo o memoravel Y. Dicionrio T cnico de In!ormtica "ed por 4arlos E. Horimoto, o saudoso escritor de uma das melhores distros 6inu 8. escritas ateh o presente momento %*urumin 6inu &, baseada no nosso amado Debian, unicode ' issoY

Wnicode n#o ' nada alem disso acima. 4om esse codigo de caracteres de te to podemos escrever letras sUrias e muitos deseninhos que voc= ver no mapa de caracteres. Escreva o comando charmap no e ecutar para abrir o mesmo.

12

Dbserve que os caracteres dessa pagina estao em tailand=s, como o chrone mostra. Fsso apenas ' possUvel com a utilizacao de 9nicode, ve8a porqueY

"tente para o fato do hac)ing ser a diplomacia ma8oritaria limitrofe entre nosso povo e o resto do mundo. Wm outro e emplo de dialeto que apenas pode ser lido com unicode segueY

Dbserve logo abai o da 8anela do Hapa de caracteres %no canto inferior esquerdo para ser mais preciso& o codigo de caractere correspondente a letra siria acima %acima dos sh/ts do bro?ser&, verifique a presenEa do W, de unicode. Escreveremos essas duas letras usando 8avascript.

13

;unicode.htm<

Dois fatos importantes devem ser mencionados agora. D primeiro ' o fato de muitas aplicacoes nao conseguirem ler unicode. Se voc= copiar esses caracteres do bro?ser e colar em um arquivo de te to e logo ap-s tentar salvaBlo com a codificacao "$SF tradicional voc= vera issoY

2or favor n#o dei e de notar a codificacao big endian %voc= entenderah&.

14

Has mesmo assim voc= n#o conseguira l=Blos se abrir o arquivo com o notepad.e e, voc= verah o que costumamos chamar de li oY

" mesma coisa apresentada acima. 2ra ler as letras voc= precisarah abrir o arquivo com algum editor com suporte a unicode, como o prorio ?ordpad por e emplo.

4ada caractere "S4FF equivale a Q byte %" 1 V NQ em he &. 4rie um arquivo de te to contendo M caracteres "S4FF com o documento formatado em "$SF default.

Dbserve que o arquivo pesa M bytes. Fsso ' bom para voc= que estah apredendo sobre as unidades de medida de armazenamento. 4ode um prog que vai aumentando os dados no arquivo para voc= ir vendo a olho nu as escalas. 4omo todos sabemos depois do nibble vem o byte que ' o con8unto de O bits, a partir daih a unidade de medida ' de Q/5N em Q/5N. Le8aY

Escreva apenas mais uma letra a no arquivo de te to e salve para ver que a escala mudou.

Depois do *+ vem o H+ %Hega +yte&, depois o J+ %Jiga byte& e assim por diante. $ao ' o foco. Esse conhecimento ' muito important para acelerar %se for o caso& a escrita de shellcodes e a pratica de fuzzing, pois podemos escrever os 8un)s na unha %por isso tenho unhas compridas, ' mais abrangente. sem tornar o paper pe8orativo... claro <). 1&

$earnin% the #unctions: escape()! - unescape()! - toString()!

4omo voc= pode observar no script unicode.htm primeiramente %entre aspas mesmo& foi alocado o caracter =u0#*6 na heap e logo ap-s o =u0#)?, mas durante e ecucao o que foi apresentado primeiro foi o caracter da direita. "qui acontece o mesmo quando escrevemos e ploits de +/f, ou se8a, os dados s#o alocados em ordem inversa na memoria devido ao ordenamento de bytes. 4omo 8ah mencionado previamente o intermediador limitrofe entre o userland e a programacao de processador %n#o necessariamente ring/& por assim dizer, no qual fazemos uso de instrucoes escritas em assembly %em he adecimal& e onde tudo estah em he %incluindo os enderecos de memoria virtuais e fisicos&, ' o %se da pelo uso do& 8avascript. Wma funcao bastante conhecida do mesmo ' a unescape%&, tendo como seu antonimo a funcao escape%&.

escape()!
Encoda uma sequencia de te to.

Sinta e.Y

$ote que o correspondente ao espaco em he adecimal ' o / & %em ' V 5/&, ou simplesmente (5/. 4omo voc= pode notar a notacao percentual % #& delimita uma sequencia he a no (S. Du se8a, o que a funcao escape faz ' simplesmente converter os caracteres especiais em seu formato he adecimal quando assim for possivel. 1'

Dbserve atentamente que o (at+ ou $ no foi alterado. Le8a logo mais abai o um source code que imprime na shell o correspondente "S4FF dos digitos he a / 5/ e / NQ. %% example&.c %%
$include %stdio.h& main ()' ,rint! ("=c=c=c=c=c9n", 0"*0, 0"*0, 0"*0, 0"*0, 0"6)); }

unescape()!
Em contrapartida a funcao escape%& temos a funcao unescape%&! que faz o processo inverso ao de sua irmazinha. "o se8a, com ela estamos aptos e converter he em "S4FF. Esses scripts tambem podem ser usandos para encriptar suas conversas em He , a chave ' fraca, mas pessoas leigas n#o conseguirao saber o que voc= e sua mina estao conversando.

unescape&.'tm 1(

Se quiser testar escreve %3F%20%5C%20%20%24%24%20@@AAAAA na cai a de te to 7regarding solely pass?dsS7. D interessante dessa funcao ' o fato de que 8ustamente com ela nos ' permitido inserir dados na Heap, mas como 8. mencionado, em ordem inversa e cada sequencia necessita ser de dois bytes, ou se8a, quatro digitos em he adecimal denotados com o [u de unicode. Lamos ver como ' a conversaoAisso na pratica manoh, sem aquelas analogias toscas de prato %pffC&.

" conversao para #unicode acima usando a funcao unescape%& voc= 8. pegou. "gora voltaremos novamente a funcao escape%&!

"bra novamente o mapa de caracteres do ?indo?s e escolha uma letra unicode qualquer. 1)

$o meu caso em especial foi a letra abai o a escolhida. Dbserve que essa cai a de dialogo tem suporte a unicode ;)

Loce poderah verificar o resultado abai o.

Dbserve que a pr-pria funcao escape%& decodou o nosso caractere e nos mostrou o codigo [unicode do mesmo, serahS

E ato e perfeito. Humm... Entao isso quer dizer que, se inserirmos [u/MMN no nosso script do unescape%& ele vai ,decodar, esse caractere %ou se preferir uma string& e converteBlo%a& em unicode %assim fazendo nos vermos&S Sim, ' isso. Humm.. "gora ' a chave de tudo manoh, se voc= pegar isso aqui voc= pega praticamente todo o Heap Spraying E ploitsKriting. "bra o "lessandra e logo apos forneEa a ferramenta a string +lac)fo para obter os seus correspondentes em HE>.

Escreva %42%6 %6!%63%6"%66%6f%#$ no unescapeQ.htm para confirmar.

"gora vamos escrever o script de alocacao.

Julin'a.'tm 1*

"gora finalmente rode a page % Julin'a.'tm& e ate o processo ao Fmmunity para procurarmos a string alocada na memoria desse processo.

D i, nada de unicode stringS Hum... Stranho...

@an damC "chamos a string, mas espere aih, alocamos B"S4FF instead of BunicodeS Sim isso mesmo. "gora veremos como uma "S4FF string ' alocada na memoria %;Heap<&.

4omo voc= pode observar cada caractere da string equivale a Q byte %dois digitos em he a& e s#o agrupados um ao lado do outro na memoria. Entao podemos inferir que a Heap ' uma memoria de acesso contUguo, ou se8a, alocacoes destinadas a essa regiao s#o deterministicas, os dados s#o escritos um na ad8acencia do outro. \ essa caracteristica peculiar a Heap que permite a nos %a banda podre& codar e ploits de Heap Dverflo? que corrompem os ponteiros da memoria, mas isso n#o vez ao caso agora ,) D que importa aqui ' como eu fiz isso. 20

@ambem eh de conhecimento geral que unescape%& lida com unicode, e apenas com esse tipo de alocaE#o. WhS Entao como foi que conseguimos alocar "S4FF usando unescape%& na memoriaS D que acontece ' que enganamos ele %que buro }<) Dbserve a estruturacao do sourceY

(ah que sabemos como o unicode ' estruturado na memoria, for8amos um falso unicode. %malandro@is7i& " estruturacao do (avaScript em si n#o ' de dificil compreensao. Has 8. que este documento foi escrito para nossos ilustres S)s %acronimo para Script *iddies& vou e plicar a base. " variavel str vai armazenar o resultado do unescape%&!, ou se8a, a string +lac, e logo abai o estou dizendo sem meias palavras queY str 1 str X )fo . Essa linha concatena ao final de str o resultado da segunda funcao unescape, ou se8a, )fo . 6iteralmente quer dizer str ' igual a ela mesma ,X, o resultado retornado de unescape%&, assim ane ando ao termino de +lac o fo e fazendo com que ela ane ada este8a armazenada na variavel str. E iste um alias para essa estruturaY str X1 unescape%&. Eh bem mais simples nao achaS E corresponde exatamente a mesma coisa %quem dera eu tivesse um te to desses quando comecei... ,). "ih a puta alih no canto falaY 4omo ' que voc= sabe dissoS. Essa falha de seguranEa %que ainda prevalecerah por muitos anos, ou enquanto nos e istirmos& devidamente batizada de Heap Spraying foi originalmente descoberta por um hac)u chamado 72lined bem antes de 5///, o cara depois de ter e ploitado ateh o pentagono resolve publicar a dita %HS/QB/::&, mas a falha sempre esteve lah s- esperando para ser descoberta bem antes de ser documentada 1& 4omo voc= pode ver abai o.

21

DuhC 2odemos ver que a memoria estah cheia de "+4DE3JH... D Cmona ' tao poderoso que voc= apenas precisa fornecer a ele um trecho da string que ele se encarrega de encontr.Bla por completo no dumping. Saber isso ' muito, muito importante (;)

Has espere, nem uma das ocorrencias eh concernente a ;Heap<. Entao, onde estah localizada nossa string na memoriaS Sabemos que nossa string eh alocada na heap, apenas analisando as "2Fs %ou +ibliotecasA$ibraries B apenas sinonimos& que s#o carregadas na memoria em tempo de e ecucao. Wm bom embasamento pra voc= se calcar nesse inferimento s#o as funcoes contidas nessas, no qual podem ser vistas usando o Fmmunity ou com a tool que o Dar)Tside codou. D que sabemos tambem devido a algum conhecimento previo %se8a em um dos meus outros documentos ou videos sobre invasao& que, a memoria trabalha no que costumamos chamar de 6F3D %last in, first out .vide a deleitosa phrac)&, ou se8a, ultimo dentro, primeiro fora. Seguindo esse conceito lembramos que a funcao unescape%& foi escrita com o proposito de lidar com ambientes %6F3D&, ou se8a, podemos inferir que a mesma segue esse consenso. 4om esse ponto de partida chegamos a seguinte mutua conclusao de organizacao de bytes na memoriaY

$a primeira linha veremos o correspondente a cada letra "S4FF descrita abai o. Has por que dois pares de Q bytesS 6embramos ent#o que unicode aloca dois bytes para cada caractere, como 8. vimos no dumping da memoria (6* 00 A 5.) .

22

4rie um arquivo com um nome qualquer, o de minha preferencia eh unicode)imeratest.t t logo ap-s sete a codificacao do mesmo para Wnicode. E ve8a em suas propriedades o tamanho.

Loce se pergunta agora, como um arquivo sem nada dentro pode pesar 5 bytesS D que acontece ' que a formatacao %que nada mais ' do que uma praparacao para receber o caractere unicode& pesa dois bytes. Lamos selecionar no mapa de caracteres do ?indo?s um caractere unicode.

$o meu caso foi a letra siria sadhe, de codigo correspondente WX/R5O. "gora coleBo no arquivo formatado para recebeBlo e logo em seguida analise suas propriedades.

(ah que n#o se faz necessaria nenhuma formatacao previa de um arquivo de te to para comportar ascii, cada caractere contido nele pesarah o seu correspondente em he adecimal, ou se8a, Q byte para cada dois digitos %V NQ&. E ecute o arquivo.

D notepad.e e n#o da suporte a unicode, mas isso n#o quer dizer que outro editor de te to n#o possa leBlo perfeitamente.

23

E se tentarmos procurar porY

"plicando o conceito de 6F3D no mais e tremo sentido %por sinal& da palavra. Sera que acabaremos encontrando a string na heapS

D i, n#o era uma string no formato unicodeS 2or que n#o a encontreiS D que acontece ' que se o mona %como todo o ?indo?s& n#o detectarem nenhuma sequencia unicode nos bytes inseridos eles interpretam os dados como sendo apenas "S4FF ]], por mais que os dados este8am estruturados %entre aspas mesmo& em unicode, mas isso ' tao obvio que chega a dar nos nervos. $ao vai adiantar procurar por unicode se apenas e iste "S4FF na string. $aoSS

2ronto, descoberta uma falha crucial de seguranEa. 3oi isso que o S)ylined descobriu. D conceito por tras do Heap Spraying ' 8ustamente esse descrito acima, ou se8a, preenchemos %spraying& a heap com a instrucao assembly $D2 %opcode correspondenteY V P/&, que como os senhores 8. sabem ' uma instrucao que quando e ecutada n#o faz nada %$D2 )o"PerationASem operacao&, nesse caso em especial ' usada apenas para ocupar espacao na memoria %Q byte cada $D2, V P/ no caso&. 24

6ogo em seguida inserimos o shellcode % )*+ , S'ellcode& que ' o que de fato vai rodar alguma coisa na maquina que vai ser invadida. " escolha do mesmo eh sub8etiva, ou se8a, voc= pode rodar um shellcode que abra uma porta @42, bai e e e ecute uma bac)door de port )noc)ing %que n#o abre porta alguma&, ou pode simplesmente rodar um shellcode que e ecuta algum comando do ?indo?s. 4om a memoria devidamente sprayiada com $D2s e Shellcode vamos engatilhar a falha, ou se8a, encher o stac) frame da funcao da aplicacao vulneravel que n#o controla dado devidamente de digitos de Q byte 7""""""""s ou +++++++++s ou se8a lah o que7 ateh alcanEarmos o retorno da aplicacao. " quantificacao se da na maioria dos casos de forma 7muito7 proli a, mas sempre com a pretencao de alcancar o ret dos programas vulneraveis.Saber isso eh crucial para lidar com frame?or) fuzzers. Eh esse mesmo retorno que vai apontar para o inicio do $D2S localizados na Heap, fazendo a memoria pular de byte em byte %e n#o fazer nada alem disso& ateh alcancar o shellcode e rodar algo malicioso na maquina invadida. 6embrando que instrucoes tambem seguem o mesmo conceito de armazenamento de bytes %um pouco obvio demais BB&.

Le8a esse e emplo.Y

D endereco #/80)*36 guarda uma instrucao $D2, ou se8a, opcode P/ %dois digitos em he a&, no qual equivale a Q unico byte na memoria. Entao podemos inferir que o pr- imo endereco serah #/80)*3C e o sequente a este #/80)*33. Dbserve tambem, a traducao dessa instrucaoADpcode %operational code ^ codigo operacional&, ou o que nos costumamos chamar de disassemble %correspondente ao opcode P/& estah logo ao lado, em verde! 7notar7 o disassemble ' importante pra quem t. comeEando a escrever soft?ares em assembly %nunca mecha com os )ras da @H4, esses coroas s#o maus&." stac) possui a peculiaridade de crescer de N em quatro bytes convergindo em direcao a enderecos bai os %isso quer dizer que ela trabalha decrementando as unidades ad8acentes he adecimais ao endereco corrente de ,3, a ,/, %mas na pratica esses enderecos s#o reservados ^ / ///////M e / ffffffff&. @anto ' que essa stac) abai o comeca no endereco 0*D*FFF/. 2&

2ropiciando o crescimento %pra bai o, como voc= 8. sabe& somente de N em N bytes.

//5533"N era o topo da stac), depois da subtracao normal do stac) frame passou a ser a base. Wm fato que me chama a atencao eh que todas as vezes que 8ogamos dados sobressalentes sobre o topo da stac) %/5O53344& em um overflo?, a memoria tambem tomara o topo da stac) como base para crescer em direcao divergente a e ecucao normal!

Dbserve que o topo dessa stac) no overflo? eh o endereco //5533R/ e ' o endereco sequente que na realidade ' sobrescrito. D endereco de final RN guardava //:3NQ//, e depois da insercao de mais quatro bytes no code de overflo? passou a ter NQNQNQNQ. D de final RO, //:35"PO, depois //:35"// e depois por sua vez NQNQNQNQ e o de final 4 voc= 8. sabe. Dbserve o screesh/t abai oY

2'

D topo da stac) s- vai dei ar de ser final zero quando toda %entre aspas& a memoria ' sobrescrita. $esse caso acima faltam apenas N bytes para isso acontecer %ve8a o finalzinho&.

"ssim alcanEando o inicio da stac) no processo normal e o fim, na e ploracao.

$os capitulos sequentes falaremos sobre SEH e ploiting 7ui7 l::t. Ds dados que sobressaem as ad8acencias da corrente s#o registrados assimY

2(

@enho um segredo pra quem gosta de fuzzing manual, para ver como os registradores se comportam ao recebimento de dados. $o DevB4XX e iste um contador na parte inferior da interface.

4erto, o que aquele //553334 quer dizerS Fsso quer dizer que o que costumamos chamar de base sequencial de enderecamento %em he adecimal& segue esse criterioY / ^ N ^ O ^ 4. Dbserve que por se iniciar em 4, a base sequencial soh pode ser multipla de N bytes. Essa tabelinha que criei sempre vai te a8udar a determinar a base sequencial das alocacoes, se8a na heap ou na stac) %da stac) voc= 8. sabe p_&. "tente que a 9nica coisa que se faz necessaria para usar a tabela ' a marcacao do primeiro digito %da direita pra esquerda& do endereco mais alto, da heap ou da stac). +asta que voc= arraste a barra de rolagem ateh o final de ambas no Fmmunity para ver qual ' esse endereco, que no caso da stac) ' sempre terminado em 4 .

Dbserve nitidamente na stac) acima que ateh mesmo os numeros ad8acentes estao dispostos de N em N bytes %3333EEEEDDDD&, que como mencionei regridem de 3 a /, dando a entender que a stac) cresce pra bai o. " stac) no Fmmunity costumeiramente ' localizada no canto inferior direito da 8anela principal. @ambem eh atraves dessa regiao do debugger que verificaremos a base e o topo de uma corrente SEH durante o processo de e ploracao de um programa vulneravel.

Se prestares bem sua atencao notarah o porque da base sequencial ser sempre multipla de N bytes. Le8a acima que a stac) n#o lida com alocao de dados diretamente, mas sim com enderecos de memoria, e apenas com eles. " stac) opera em quatro em quatro bytes porque precisa comportar enderecos de memoria, ou se8a, / //////// %cada dois digitos, Q byte, e aih temos O deles, N bytes %in hard?are de :5 bits&, mas a heap n#o. Ela trabalha de acordo com os bytes que serao alocados 2)

%instrucoes ou "S4FFs&, mas sempre ordenando os tais de dois em dois bytes %unicode&, por que afinal de contas com unicode ela pode lerAacoplar qualquer coisa %vamos ver em seguida o porque de eu saber isso&. Se estourarmos algum buffer em algum programa vulneravel com """""""s em userland, a stac) serah sobrescrita com NQNQNQNQNQNQNQ %seu correspondente em he & em machineland e merda acontece, porque o endereco de retorno do stac) frame vai retornar %ao inves de endereco de memoria& um monte de ".

$include %stdio.h& $include %string.h& main ()' char stac7(6+; char E,ointer="-------------------"; strc,2 (stac7, ,ointer);

perereca.c

Wma coisa que sempre gosto de fazer quando to fuzando uma app ' analisar a dita soh no Fmmunity. $ao perco tempo procurando indicios de overrun sem t. de olho na memoria, como crash ou verificacao de e cecao %sim, sou du undigrud&.

$ittle *ndian +s ,ig endian

4erto, vamos fugir um pouco do escopo do te to somente para e planar esses ordenamentos de bytes. "credito que todos voces se lembrem de como se da um overflo? tradicional, de outra modo reveremos %n#o precisa pular o capitulo, ' breve&. " 4orporaE#o LUbora e pediu uma otima publicacao concernente a Stac) Dverflo? sobre o K:5 %procure no usrfiles! antigo hunterhac)er do tempo que eu era *iddie&. @alvez a qualidade 8ustifique seu favoritismo 8unto a nossos documentos, mas n#o ' isso que esta em pauta aqui.

2)

$include %stdio.h& $include %string.h& main ()' char stac7(6+; char E,ointer=F----5555GGGGF; strc,2 (stac7, ,ointer); }

4omo voc= pode averiguar nessa esplendida publicacao %sem demagogia eheh espero que tenham gostado 1&, esqueci de mencionar o tamanho variavel do dummy. 2ara alcancarmos o ret desse code acima nao se faz necessaria a insercao de dummie algum. Du se8a apenas precisamos encher o buffer da dados %;N<A""""& e sobrescrever a base do stac) frame %ebp 1 5555& ateh alcancarmos os N bytes do ret %eip& em azul % GGGG= );

Esse log %log ?indo?& mostra que ocorreu um erro de violacao de acesso ?hen e ecuting the supposed address 05050505.

$o gdb a sinta e ' a seguinteY

Lamos aumentar o buffer da aplicacao para o seu numero multiplo seguinte, ou se8a stac7(D+; e abrir a mesma com o Fmmunity ap-s devidamente compilada. Seguiremos dessa vez o seguinte criterio de enchimento.
tac7(D+;

E tended +ase 2ointer %ebp& ret

1 """""""" O bytes 1 ++++ 1 IIII 30

"lcancamos outra vez o retorno com esse enchimento. "umentamos agora para stac);Q5<. Sempre o multiplo sequente. $ao dei e de notar o E+2.

$ada parece ter acontecido.D que houveS D compilador para se adequar ao ?indo?s inseriu um dummy ao stac) frame. Lamos saber identificaBlo agora. "ntes de mais nada gostaria de enfatizar que este ' um documento concernente ao ?:5, e n#o ao GNU/Linux.
Stac);Q5<! 4ontador Dummy E tended +ase 2ointer %ebp& ret 1 1 1 1 1 """""""""""" Q5 bytes $$$$ % N bytes & -------O bytes ++++ GGGG

char E,ointer="------------HHHHIIIIIIII5555GGGG";

Le8a neste capitulo como identificar a multiplicidade do dummy. 2ara esse proposito inseri um counter antes de O bytes do dummy de um buffer de ;QM< para tomaBlo como ponto de partida e fazer distincao dos mesmos dando a entender que s#o unidades independentes uma da outra. "bra e rode o prog dentro 8. dentro do immunity %3P&Y

31

Dbserve aih acima que o registrador E"> ' setado com o valor da variavel, ele costumeiramente recebe o argumento argv;Q< nos te tos do d A gc eehehe %o )ra man8a muito&.

4onseguimos mais uma vez sobrescrever os ponteiros da memoria ateh chegarmos na area ret. Lamos aumentar o buffer seguindo aquele criterio da multiplicidade. Dessa vez n#o inseriremos contador algum, com o intuito de acharmos algum padrao comum na analise. char stac);QM<! char 7pointer1`""""""""""""""""DDDDDDDD++++IIII`!

char stac);5/<! char 7pointer1`""""""""""""""""""""$$$$$$$$$$$$DDDDDDDD++++IIII`!

"i.

char stac);5N<! char 7pointer1`""""""""""""""""""""""""$$$$$$$$DDDDDDDD++++IIII`! %FD M:& char stac);5O<! char 7pointer1`""""""""""""""""""""""""""""$$$$DDDDDDDD++++IIII`! %FD MN& char stac);:5<! char 7pointer1`""""""""""""""""""""""""""""""""DDDDDDDD++++IIII`! %FD M0&

%a& "pro ima sequencia para encher o buffer ent#o serah :M X a quantidade de $s roseos onde estah o DiC "lih em cima X O de dummy X a base do stac) frame X o retorno. Sempre nesse ciclo, certoS

D bagulho eh facil manoh. Entao pra estourarmos o buffer;05<! devemos por sua vez entrar com o $$$$$$$$$$$$DDDDDDDD, porque ' o sequente ao DDDDDDDD . "gora pense no $ e D como sendo a mesma coisa, pronto G1R 32

Huitas pessoas se perguntam o porque de se fazer necessario a insercao dos bytes referentes a endereco de retorno de forma inversa. Fsso se deve ao fato que chamamos de ,ordenamento de bytes,. Eh o ordenamento que dita como os dados serao postos na memoria. Dlha, esse assunto causa muito confusao, mas a base ' a mesma, a simplicidadeY .+ig Endian V "+V 4DV E3V Q/ .6ittle Endian V Q/V E3V 4DV "+ "gora pode ler isso abai o. "lgumas arquiteturas usam o ordenamento intitulado +ig Endian, onde o bit mais significante comes firstAvem primeiro ou se8a, se quisermos retornar um endereco nessa arquitetura como / "+4DE3Q:, precisariamos entao escrever no e ploit dessa maneira V "+V 4DV E3V Q:, tendo em vista a maior significancia das letras sequenciais sobre o numero. Em 6ittle Endian ' o processo inverso, tendo em vista a prioridade do menos significante! arquiteturas intel. Fsso quer dizer que se quisermos retornar para o endereco %vamos supor& //N/Q5P/, deveriamos escrever no e ploit `V P/V Q5V N/V //`! tendo em vista que o // ' menos significant $"D SDh "2E$"S em seu nivel hiererquico, mas tambem no que diz respeito ao posicionamento dos enderecos no ordenamento. Enderecos altos +uffer;:<! +uffer;5<! +uffer;Q<! +uffer;/<! // N/ Q5 P/ //N/ Q5P/ / //N/Q5P/

Enderecos bai os D processador vai entao rodar o ret adequadamente.

Lamos determinar a base sequencial da heap desse code perereca.c acima %no qual nao faz uso da mesma&, ou se8a, apenas aloca dados na stac) como todo bom prog G,)

+astando olhar para a heap podemos inferir como ' dada a sua estruturacao de alocacao de bytes %base sequencial de enderecamento&. Wsarei a tabelinha como base da e planacao. Dbservem abai o senhores que o que vamos chamar de agora em diante de ad8acentes, na heap, se repetem duas vezes, na stac) se repetem N, insinuando que a alocacao se da de quatro em quatro bytes. Dbserve agora que, o endereco corrente vai de O %maior& a N %menor&, ve8a o fim da heapY

Iepare alih que os enderecos ad8acentes ao corrente sao decrementados partindo do maior numero he adecimal %a base numerica que o processador usa&, ou se8a, o 3 % FF??II, sempre regredindo e em dois em dois, no caso da heap em especial, devido a peculiar caracteristica de manipulacao de unicode&. Entao podemos inferir com isso que ela cresce pra bai o tambem %baseY//N/5/// to topY//N/533O&. De posse dessas informacoes montamos esse diagrama. 34

Du se8a, s#o situadas em e tremidades opostas e convergem na mesma direcao %se calque em suas respectivas bases e topos para, de posse dessas informacoes, construir um diagrama melhor concernente a essa contraversao&. Se olhares de forma minuciosa 8unto ao endereco corrente perceberah que a pressuposta 9nica forma mais coerente de alocacao para esse criterio %O e / ou / e O& tendo a tabela como base, ' esta que se segue.

01234567 89ABCDEF
De oito em oito bytes. Loce agora fala. Hum... o f/ ta me sacaneado... Entao vamos provar %abrir outro e ecutavel qualquer para analisar sua heap&. Escrevi um code que aloca dados na heap usando malloc%&! e clusivamente para esse proposito %alocar dados na heap para uma posterior analise&! como a funcao malloc%;) "penas por mutuo desencargo de consciencia.
$include %stdio.h& $include %stdlib.h& $include %string.h& main ()' char string(+="-5/I?FMQ0RSOLHPTU ", E,ointer; ,ointer=(char E)malloc (siKeo! (char) E strlen(string)+)); strc,2 (,ointer, string); s2stem (",ause");

JJ malloc (siKe4t) 44L0HMN4-;;G054L-OOP/; JJ strc,2 (charE, const charE);

JJ JJ

-5/I?FMQ 0RSOLHPTU 0)*36C3# D8-5/I?F

"penas pra fazer distincao dessa sequencia das outras que possam vir a e istir tambem na memoria %como voc= viu a algumas paginas&, inseri 8unto ao termino da string as letras .

3&

2rog rodando %copiado pra memoria& e a string -5/I?FMQ0RSOLHPTU vamos procurar por ela.

8ah estah na heap, entao

3oram encontradas duas ocorrencias da mesma string na memoria, uma na stac) e outra na heap. 6embreBse de que a%o& stac)%stac) frame& ' usada para armazenar enderecos de memoria de retorno de funcoes e antes de mais nada valores de variaveis %char string(+&, ou se8a, antes de copiar a string pra heap com a malloc%&, inicializei a dita, e por isso ela foi copiada da stac) para a heap.

6embreBse de que n#o vou procurar por essa string e orbitante porque isso 'h coisa de lamah, e eu sou hac)u da elite, da mais undigrud elite hac)a, s- abai o dos coroas da @H4 e do Struc), e por isso resumi a mesma na sinta e de busca %LHPTU ). Desse ponto para o inicio da mesma s#o e atos Q5 letrasAcaracteres "S4FF, ou se8a, Q5 bytes. EntaoY

Dbserve que o Fmunidade %duhC& mostra os dados de O em O bytes em He adecimal e "S4FF em cada linha no padrao de visualizacao He A"S4FF %O bytes& ]] +asta clicar com o botao direito do mouse na heap pA alternar entre os padroes de visualizacao.

3'

D que voc= precisa agora ' alternar para esse ao ladoY

Dps, alguma coisa n#o deu certo. Iepare alih que o endereco de memoria //:3:"+4 guarda o opcode P" /Q/... repare que o dissasembly %a traducao desses opcodes& corresponde e atamente as letras iniciais da string que inserimos na heap %NQ, N5, N: ^ ", +, 4 respectivamente&.

"bra a 8anela de log do immunity e vamos chamar ,call, esse endereco a partir de lah.

2imbaC Era isso que tUnhamos que fazerC Josto de pensar essa phrase quando to 8ogando 12 Entao a nossa string comeEa a ser escrita na memoria e atamente no endereco //:3:"4/. "gora ent#o finalmente posso e planar o funcionamento da base sequencial de enderecamento. Lamos tomar como base essa montada na memoria mesmo. "credito que voce se lembre qual a base sequencial de enderecamento que a heap usou para esses dados dados. / e O lembraBseS Seguindo aquele conceito da stac) ent#o ficariaY /Q5:N0MR OP"+4DE3 7esse sim tem coerencia7. 6et,s see itC 3(

-5/I?FMQ 0RSOLHPT U 0)*36C3# D8-5/I?F 0)*

//:3:"4/ 1 " //:3:"4Q 1 + //:3:"45 1 4 //:3:"4: 1 D //:3:"4N 1 E //:3:"40 1 3 //:3:"4M 1 J //:3:"4R 1 H //:3:"4O 1 F //:3:"4P 1 ( //:3:"4" 1 * //:3:"4+ 1 6 //:3:"44 1 H //:3:"4D 1 $ //:3:"4E 1 D //:3:"43 1 2 //:3:"D/ 1 b //:3:"DQ 1 S //:3:"D5 1 S

90

%n#o precisa ser engenheiro pra entender&

Le8a aih na sua heap que o endereco corrente ' / e O, mas o ad8acente continua se repetindo em dois em dois, dando a entender que a alocacao ' feita de dois em dois bytes apesar de tudo. Entao para todo tipo de alocacao vai ser assimY

4ompreende agora o que toda essa versatilidade do endereco corrente na heap inferiS bue ela pode alocar qualquer tipo e quantidade de dado, mas sempre com o padrao unicode sendo seguido. Lou codar um e ploit local para o programa 4ommuni4rypt Hail Q. , para servir de base, rela a. Lale enfatizar que n#o vou usar o metodo de e ploracao de overflo? tradicional, vou sobrescrever os ponteiros da memoria ateh alcanEar o SE Handler, ou se8a, vamos escrever um SEH e ploit. "eeeC D que veremos de agora em diante ' como carregar o modulo vulneravel a Heap Spraying pra memoria usando (avaScript e como o +S@I header ' disposto na mesma! ou voc= pensou que era simples assim essa tecnica dos hac)aS Has antes ve8a como ' uma heap sprayadaY

3)

D retorno do stac) frame da funcao vulneravel contida no modulo a ser e ploitado vai saltar para %nesse caso em especial& o endereco de memoria /M/M/M/M, endereco esse que guarda $D2s, e tudo desse ponto em diante serah $D2s ateh alcanEar o inicio do shellcode, ou se8a, os opcodes que e ecutarao uma dada acao. Wm outro detalhe que acredito que se8a importante ressaltar ' o fato de que podemos importar um e ecutavel para o Fmmunity passando parametros para o mesmo durante a importacao. 4omo voc= pode ver logo abai o.

+asta inseriBlos no nada sugestivo campo ,"rgumentsY,, ou se8a, para o proposito de fuzzing, um chun) de """"""""""s ou qualquer outra coisa. Lamos dar prosseguimento ao material.

,uscando o endereco de retorno

%html& %scri,t t2,e='te"tJVa@ascri,t'& @ar nic7 = new tring("345l6c784!0"3"); document.write(nic7 + " is on memor2"); window.alert ("Tress P7 button to !ree u, memor2 s,ace"); window.close(); %Jscri,t& %Jhtml& ,lent2o!b2tes.html

3*

Encontramos dois ponteiros para Bascii na heap, vamos ver para unicode.

Fsso infere que os dados s#o postos na heap tambem como "S4FF e de alguma forma mediunica s#o convertidos em unicode %digo isso porque escrevemos "S4FF! o que estah no endereco de final Qa e 5a& e realocados %postos em enderecos distintos sequenciais partindo da alocacao do ascii! //5/cf5a para //5/eP/N, que por incrivel que pareca, ' multiplo de 5 1&. 2ara saber isso basta escrever uma potencia de acordo com o endereco, na calculadora 7he 7, ou se8a, X %no caso& e depois ' s- ir apertando enter que vemos o seu multiplo 7cuidado para n#o sobrepu8ar7 ]] "prendi isso com a minha professora de matematica lah de bui eramobim, do liceu %man8a muitoC&, mais uma ilustre fomentadora da cena hac)er brasileira %mesmo que indiretamente&. Depois do reboot da minha maquina refaco os testes de buscas e obtenho esse resultadoY

40

$ote esse padrao de escrita na heap, talvez se8a util pra ti como ponto de partida para uma posterior mais aprofundada analise. Se bem que em uma outra ocasiao aloquei uma string distinta e obtive um resultado controverso a esse, mas.. 74omo o $ash mesmo falou7 "credito que nenhum sistema do mundo rode de forma totalmente aleatoria, as maquinas devem %por questao de logica& seguir um padrao de operacao. @alvez funcione da mesma maneira que um )eygen que gere um codigo de ativacao de acordo com uma string escrita, enfim, o padrao de alocacao pode se da de diversas maneiras, cabe a voc=, com o seu suor, descobrir qual 7eu vou terminar mais um 8ogo no meu ps57 <) @ambem acredito que n#o tenha mencionado o fato de eu estar mandando esses shots do >2AS25, mencionei o terceiro issue da franquia %Service 2ac) :& no inicio do paper por mera formalidade, pois o shellcode que vou utilizar %a efetivacao do ataque propriamente dita& roda em ambas plataformas, bem como as sinta es %endereco de retorno& e conceito.

Lamos dumpar esse endereco com o comando d //:PcM0c. Essa instrucao corresponde e atamente ao duplo clique sobre o endereco na 8anela de log! s#o apenas aliases para se chegar ao mesmo local dentro do Fmmunity %no qual vemos como estah distribuida a memoria referente ao programa&, o dumpY

Dbserve que as strings que alocamos na heap sao convertidas em unicode, 5 bytes %voce sabe o porque&. Dessa vez a funcao utilizada para a alocacao foi a new tring("345l6c784!0"3");. Dumpe os quatro bytes previos a esse enderecoBN. Le8a esse sh/t pra lembrar de que as strings na heapAa heap cresce do menor endereco pro maior e para ver que todo o codigo da pagina tambem <)

Le8ah que ateh o codigo chtmld estah na heap. Le8a o topo da heapY 41

Dbserve que a base ' //:P//// e ela vai crescendo de / a O %para o e emplo de alocacao que dei a ordem n#o importa&. $a medida que ela cresce os enderecos vao sendo incrementados e bytes vao sendo inseridos na mesma proporEao, ent#o isso infere que d //:PcM0cBN alcanEa quatro bytes antes da string. E ' e atamente isso que queremos.

" cabe/alho ,S01

4omo voce viu, quando uma string eh alocada na memoria ela eh convertida em unicode, um detalhe que nao mencionei ateh o presente momento eh que essa unicode string na verdade estah dentro de um header chamado +S@I B +asic String or binary string, nao vou pormenorizar o tema, basicamente saiba que esse header estah disposto da maneira descrita adiante. Ieiniciei a maquina mais uma vez e rodei o script plentyofbytes.html mais uma vez, soh que dessa vez a string eh
Wmona !ind .s "ra,osanegra" .unicode ." E

Has o endereco ' o mesmo do test previo. " principio podemos averiguar que a 9nica distincao entre ambos os logs eh o segundo endereco na heap %final cRfe B ;heap<&

Dessa vez a escrita foi um pouco mais abrangente, no que diz respeito a padroes, pois alcanEou o endereEo / /Q0:P:MN 7ta um pouco cortado no log acima7! esse eh um dos resultados dos logs previos %depois do ultimo endereco marcado no sh/t 7vide final da pag. N/7&. Lamos dumpar o endereco selecionado %d / //:PcM0c&! 42

Escreva no interpretador de comandos o mesmo comando de dump, soh que dessa vez voltaremos N bytes antes da string com o intuito de vermos o inicio do header no qual essa string faz parte. $ao eh nem de longe dificil entender o header %soh se voce for muito mula ^ lembreBse de que esse documento eh privado 1& 7os macacos que se fodam7. +em, primeiramente ve8a onde ele se inicia no dump %d / //:PcM0cBN&!

Du se8a, N bytes antes da string. Dbserve abai o que o header termina com dois caracteres nulos logo apos o fim da string em unicodeY

Iisquei um diagrama abai o pra e planar melhor o bagulho.

Em Size temos nada mais que quatro N bytes destinados unicamente a mostrar o tamanho %em he adecimal& da string em unicode logo ao lado! esse valor n#o inclui o terminador de stringV/. " string raposanegra possui QQ caracteres, mas vale te lembrar de que, 8. que se trata de uma string unicode ent#o cada caractere ocupa dois bytes na memoria devido a insercao do // ao fim de cada letra "S4FF. 2ortanto essa string ocupa 55 bytes em decimal %dec na calculadora&, e seu correspondente em he adecimal equivale a 43

Escreva qualquer numero decimal %dec& na calculadora cientifica %opcao e ibir .& cientifica& e logo ap-s marque a chec)bo he para ver o seu correspondente em he a. @e lembrando de que o esquema de ,/, a 3 eh soh pra enderecamento, na calculadora eh apenas Q a 3.

$ecessitamos deter um previo conhecimento basico a cerca do +S@I Header com o principal proposito de evitar transtornos futuros durante a escrita do e ploit. Escreverei um script para e por bem o que quero dizer com transtornos.
,ra2ing.e!!ect.html %html& %head&%title&-llocating%Jtitle&%Jhead& %bod2 bgcolor='blac7' te"t="$FF0000"& %scri,t t2,e="te"tJVa@ascri,t"& JJ 0 dream o! when this gras,ing will end m2tag = unesca,e("=u#C3c=u3#3e=u#C36=u3b#3"); JJ lungdus7 Xuantidade4de4blocos = *00; tamanho4do4bloco bloco contador = 0"6000; = ''; = 0"00; JJ 0"6000 E * = 0"D000 (3*#3D dec) JJ ,ahW JJ initialiKing JE it'll be li7e sort o! an arbitrar2 number 0 .<T EJ JJ aloca 0"D000 b2tes de no,s . 3*#3D in decimal while (contador % tamanho4do4bloco)' bloco } JE se inserir mais "um" =u8080 o resultado seria /000 68)C* 0"6000 E '3' instead o! two (a cada dois b2tes o acrescimo eh de )); Vum,in = "%br&"; JJ to tring() eh mais hac7u saiK = bloco.length.to tring(); EJ = bloco + unesca,e('=u8080=u8080'); ++contador;

document.write(';amanho do bloco ateh aXui< ' + saiK + Vum,in); bloco = bloco.substring(0"00, tamanho4do4bloco . m2tag.length);

document.write(";amanho do bloco agora< " + bloco.length + Vum,in + Vum,in); contador = 0"00; JJ !uncoes new da gota serena arra2!ulero = new -rra2(); while (contador % Xuantidade4de4blocos)' arra2!ulero(contador+ = m2tag + bloco; document.write('Ooo, (' + contador + '+ alocou na hea, ' + (m2tag.length+bloco.length) + " b2tes" + Vum,in); contador+=0"0); } window.alert("memor2 s,ra2ed . sto, smo7ing in hereW") %Jscri,t&%Jbod2& %Jhtml&

@entei dei ar o script menos turvo possUvel 7como voce nota7. Lamos agora analisar os resultados.

$a primeira ocorrencia voc= pode averiguar o numero decimal :5RMO, ou se8a, desse ponto e iste esse numero de $D2S na memoria. Esse ' o numero equivalente a O/// em he adecimal. "bra a calculadora escreva o decimal e logo em seguida marque a chec)bo he para ver seu correspondente. D), tudo ocorreu como previamos, observe ao lado que a volta final foi ;QPP<, ou se8a, 5// alocacoes partindo do ;/<, no qual tambem eh o inicio do indice, que nem em 4 e outras linguagens de niveis de programacao referentes a memoria, porque como sabemos o sistema usa o he adecimal inicialmente em / para enderecamento, e 8avascript %o que estamos fazendo& tambem lida com memoria. Entao o que de fato houve foiY
bloco = bloco + unesca,e('=u8080=u8080');

" cada nova interacao do ?hile a variavel bloco que foi previamente inicializada recebe essa quantidade de $D2s X1 ela mesma, ou se8a, vai sempre se enchendo de $D2s ateh a ultima interacao do laEo, para no fim comportar o valor total de / O////! mas observe que logo abai o o resultado depois do substring%& foi QM:O/, que equivale a :334. Se inserirmos mais N bytes a esse montante decimal o valor total serah QM:O/ X N 1 QM:ON, no qual possUvel como seu correspondente o valor / N/// %tamanho4do4bloco&. D leitor astuto observarah que a 9nica razao para isso ter ocorrido estah na linha anterior, no trecho de codigo concernente a passagem de comprimento %tamanho4do4bloco Y m2tag.length&. Humm.. mytag de N bytesS 3alarei adiante. " partir dai
arra2!ulero(contador+ = m2tag + bloco;

@odas as interaEoes do laco sequentes criarao blocos na memoria de ,lungdus) X $D2s,. $ao se esqueca de que previamente soh havia $D2s na memoria, mas a cunho de estudo montei na mesma mais blocos se iniciando com nossa etiqueta %lungdus)&. $os valendo do fato da Heap escrever os dados encaminhados a ela de forma contigua inferimos ent#o que as alocacoes se dao pr- imas.

5/5 ponteiros encontrados, esse dois bytes sobressalentes s#o correspondentes a inicializaE#o da variavel. @odas as vezes que inicializamos uma variavelY
m2tag = unesca,e("=u#C3c=u3#3e=u#C36=u3b#3"); JJ lungdus7

4'

Le8a alih em cima uma ocorrencia da nossa string no codigo da page, os dois pontos equivalem a pro ima linha. D outro byte sobressalente as 5// alocacoes ' a ocorrencia concernente a 7inicialiB zacao do arran8o7Y
arra2!ulero(contador+ = m2tag + bloco;

" mesma eh realocadaAreiniciada nessa regiao de memoria para que, todas as vezes que seu uso for necessario %pelo arran8o& o programa saber onde ela estah. 2or isso encontramos mais duas ocorrencias adicionais de lungdus) nos logs do imunidade % dois adicionais no S25&. D conceito de todos os progs do planeta eh esse, o prog aloca a string na memoria e todas as vezes que precisa encontraBla, vai diretamente no endereco onde estah ela };& 4erto, na 8anela de log estah escrito que apenas os 5/ primeiros enderecos de ponteiros podem ser vistos na mesma, o resto dos logs %para mais ponteiros& necessitamos abrir o arquivo find.t t %esse arquivo acima&. Entao faremos isso, vamos dumpar o endereco da ultima alocacao.
9-rXui@os de ,rogramas90mmunit2 0nc90mmunit2 Iebugger99!ind.t"t

Esse arquivo n#o ' sobrescrito, quando se faz necessaria a escrita de novos logs o imunidade se encarrega de criar um novo com o mesmo titulo! os previos ao corrente que s#o nomeados como find.t t.old, find.t t.old5 e assim por diante, sempre dando sucessao a ordem numerica sequencial.

4(

"penas como o intuito de analise vamos dumpar o ultimo endereco apresentado no arquivo de log.

Leremos agora o cabeEalho +S@I para sabermos quantos bytes %de fato& foram alocados nessa unicode string ,) d -x--./!!00%0

/e////O///... hanS Has pensei que o script havia alocado QM:ON %ve8a no logC&. 4erto, o que houveS Simples, o que ocorre eh que a propriedade .lengt' quando usada com unescape%& retorna menos quatro bytes do valor total %=u0)=u0*=u03=06&. D que houve eh que realmente foi alocado na memoria decY:5RMO he YO///, mas na instrucao abai o os dados s#o cortados pela metadeY
bloco = bloco.substring(0"00, tamanho4do4bloco . m2tag.length);

$esse caso / N/// ^ N, que equivale a QM:O/ em decimal. D que achei mais interessante e que o tal do c/d:r nao mencionou, eh o fato de que depois que a string eh reinicializada %em um indice no array& uma ocorrencia adicional eh inserida na memoria. "credito que se8a soh no S25, os testes dele foram no :. $esse caso abai o temos entao N bytes %string& X QM:O/, valor do bloco.
arra2!ulero(contador+ = m2tag + bloco; document.write(m2tag.length+bloco.length);

4)

Dbserve no sh/t acima a pro imidade entre as alocacoes. Em alguns casos voc= verah muito garbage, ou se8a, li o %na verdade s#o // // // //s& entre um bloco e outro. $o meu caso em especial tentei achar esse tipo especial de li o pra voces verem no S25 e S2:, mas sem sucesso algum! nesse caso acima e na grande maioria dos caso soh temos o li o padrao 12 Du se8a, tudo que sobressai o terminador da string %P/ P/ P/ P/&, ou se8a, o // e tudo que estah antes do inicio do +S@I header da pro ima alocacao eh, para nosso proposito em especial, li o.

6embreBse de que originalmente foi alocado :5RMO bytes %/ O///&. Entao partindo do ultimo endereco de alocacao %por e emplo& em find.t tX/ N/// temos provavelmente $D2s.

como ,re@isto @eremos o !inal do 5 ;G Qeader Vunto a 0"D000

4*

Em alguns casos eh de significativa importancia saber que o esse li o entre um bloco e outro soma bytes na memoria. D mona disponibiliza uma funca chamada offset que permiteBnos calcular o numero de bytes entre dois enderecos %podemos especificar registradores ao inves de enderecos&.

"o darmos um duplo clique sobre a guia ,he dump, podemos alternar entre O e QM bytes o modo de visualizacao, ent#o isso quer dizer que duas linhas inteiras somam :5 bytes. Lamos ver quantos bytes e istem na memoria partindo do endereco de final 5N ateh NN.

:5 em decinal %/ 5/ em he &, essa eh a quantidade de bytes entre um endereco e outro. " partir desse conceito vamos agora determinar primeiramente a quantidade de bytes entre o primeiro bloco registrado no arquivo de log e o ultimo! seguindo a forma rotineira de leitura. 2rimeiramente de cima pra bai o, seguidamente faremos o oposto disso e analisaremos os results.
Wmona o!!set .a) 0"0*3C006c .a* 0"00*3!!66 Wmona o!!set .a) 0"00*3!!66 .a* 0"0*3C006c

&0

Ds resultados de uma outra alocacao seguemY Wmona o!!set .a) 0"00)!a0C) .a* 0"033e*a!6

Sem offset de pulo negativo, limpo e en uto. Lou mostra pra voces aih como se faz a especificacao de registers.

E eu que pensei que eram soh quatro bytes hausdhuashdC +em, na pratica sao. D sh/t acima aih foi soh pra voces verem como eh que se da o bagulho. Lale te lembrar de que Wmona !ind .s "lungdus7" ." rw apenas registra as ocorrencias da string, lembreBse de que antes desse endereco e iste soh $D2 alocado. Dumpe o primeiro endereco no arquivo de log e volte alguns bytes para veBlosY

6embra da sequencia que a heap aloca os dados %cima f bai o& e ve8a que esse eh realmente o inicio de tudo, ve8a ali no canto a barra de rolagem dando a entender isso. "gora a parte que eu particularmente mais gosto ,cause absence of vanity does not mean security nor sediment.

SeguranEa vai mais al'm de implementaE#o de diretiva