Peripécias programáticas

Por baixo dos panos: O Windows e Você!

2009-06-12T10:43:00.000-07:00

Eu novamente com mais uma série de tutos, mas dessa vez explorando o windows completamente.
Você vai traçar APIs nativas, aventurar-se no ring 0 e eu prometo.. que se uma tela azul aparecer no seu computador por conta de qualquer erro, no final desse tuto você vai depura-la e saber o que causou esse erro.

Você pra ler esse tuto precisa de conhecimentos intermediário de C e se possível conhecimentos básicos de assembly.
Não tem?
Não leia.
Preguiça de ler?
Não leia pois eu acredito que o tuto todo possa formar mais de 2 ou 3 mil páginas de livro.

Avisos dados então..
Let's rock! =]

\---(BASEADO NO WINDOWS XP)---/

A primeira parte é sempre teórica.. vo mandar braza.. mora?
Então ta supimpa.

Um micro-processador possui básicamente quatro estágios.
O windows se aproveita de dois desses estágios.
O primeiro chamado de ring 0(zero) e o quarto chamado de ring 3.
Ao ring0 damos o nome de kernel-mode.
Ao ring3 damos o nome de user-mode.
O windows é um kernel-sided operational system, ou seja, o seu "código principal" está todo em kernel-mode(ring0).
O kernel do windows é o seu núcleo e ele é o dito "código principal" do sistema operacional.

O que está em user-mode não pode tocar nem ver o que está em kernel mode.
É um conceito bem antigo chamado de sand-box que impede que aplicações usuário danifiquem qualquer componente vital para o funcionamento do sistema. Por isso, se o seu programa der um erro, parar de responder ou qualquer outra coisa.. o sistema operacional será capaz de se recuperar e fechá-lo.

O micro-processador mantém-se alterando de tempo em tempo entre user-mode e kernel-mode.
Hora executa um trexinho de código daqui e hora executa um trecho de código dali.
O windows usa uma interrupção especial que força o processador a entrar no ciclo de kernel-mode.(ela é usada nas APIs por exemplo)

Mas o que são APIs?
Vamos voltar ao mundo real um pouquinho e deixar o ring0 e o ring3 de lado por um instante.

Você tem seu programa codado em C.
O compilador já passou pelos três estágios e gerou seu executável e vamos imaginar que ele só exiba a string "ola mundo!" na tela.
Mas me diga.. como seu programa sabe mostrar na tela as letras que você escreve?
Qual a resolução do seu monitor?
Quais pixels devem ser ascesos?(finjamos que pixels sejam mini-lampadas que ficam na tela do seu pc e que tudo seja tão simples assim)

É ai que entra o sistema operacional.
Ele faz todo o trabalho de se comunicar com o hardware por você.

VOCÊ --> HARDWARE --> WINDOWS -> SEU PROGRAMA

Você não precisa saber qual tipo de monitor está instalado e nem como "ligar" os pixels certos.
Você só diz o que quer escrever e manda o windows fazer o trabalho sujo por você.
Pros oriundos da programação orientada à objetos(POO), isso chama-se encapsulamento.
É a capacidade que um certo componente te dá de trabalhar com ele e com outros meios através dele, sem necessáriamente saber o funcionamento dele ou dos outros meios.

Pra quem já programou na IDE delphi sabe muito bem que você não precisa saber como a TForm aparece la ou aqueles componentes de envio de email.
Você só envia e ele encapsula toda a forma como as smtp requests são geradas e etc.

Mas apartir de agora, o que vai nos interessar, é justamente saber o que acontece por baixo dos panos do windows.

Então, como o printf do seu programa em C chega no hardware de vídeo?
Existem duas metades que se unem para isso acontecer.
O user-mode e o kernel-mode.
Vamos começar entendendo o user-mode.

O windows disponibiliza essas tais APIs.
Elas fazem várias operações e muitas vezes terminam levando as informações que você passa pra elas pra outras APIs que tratam as informações e por final, levam pra uma ultima API nativa da ntdll que chamará por fim a interrupção que fará o processador passar para ring0(kernel-mode).

Existem no entanto, algumas APIs que realizam todas as suas operações em user-mode mesmo.(que não acessam o hardware)
Nós conheceremos algumas delas no decorrer do tuto.

Então, levando em consideração o diagrama anterior, podemos muda-lo mais um pouco para:

VOCÊ <--> HARDWARE <--> WINDOWS <---> APIs <---> SEU PROGRAMA

Bem, eu vou ficar por aqui porque se não o pessoal fica com preguiça de ler..

O windows possui muitas coisas interessantes que poucas pessoas sabem, como um sub-sistema que por exemplo, é feito para permitir a compatibilidade com programas nix like.(interoperabilidade)

Vamos com o tempo conhecer isso tudo e entender porque no meu ponto de vista, o windows ainda é o sistema operacional mais completo existente.

Cya'round. =]

A enganação do décimo terceiro salário

2009-04-15T19:31:00.000-07:00

Contudo, a mais escandalosa de todas as mentiras nacionais e justamente aquela que burramente os trabalhadores mais acreditam, é a safada invenção do Décimo Terceiro salário. Para os meus 38 leitores, que certamente foram muito além do curso primário, eis aqui uma modesta demonstração aritmética de como é fácil novamente enganar os trabalhadores.

Suponhamos que você ganha 400 Reais por mês. Multiplicando-se esse salário por doze meses, temos ao fim do ano R$4.800.00. Quando chega o Natal, o generoso e cristão patrão manda então pagar-lhe o conhecido Décimo Terceiro Salário ( de mais R$400.00 que somados ao que você recebeu no ano inteiro somam R$5.200.00) e você vai para casa todo feliz com o saboroso sorriso matreiro do patrão. Agora veja bem o que acontece quando o empregado, ao invés de ouvir as catilinárias dos Lulas e dos Vicentinhos, procura um simples professor de aritmética do Primeiro Grau e que lhe ensina que você sabiamente faça o seguinte :

Você vai ao seu patrão e lhe diz : Patrão, lamentavelmente meu salário é pequeno e como eu tenho que pagar contas de luz e gás durante esse período e não posso esperar até o fim desse mês para pagar contas atrasadas, rogo-lhe que, como meu salário é de R$400.00 mensais, pague-me R$100.00 por semana (o que dá na mesma coisa – 4 semanas a R$100.00 somam R$400.00 ). O distraído patrão concorda ( concorda porque por vezes ele também pode ser burro) e assim fica tudo acertado e você volta para casa tranquilo, porque afinal de contas seu patrão fez-lhe apenas um modesto favor que não lhe custa nada.

Mas aí é que está o engano. E eu pergunto aos meus 38 leitores: Quantas semanas tem um ano ? Resposta inteligente : 52 semanas! Já percebeu a jogada ? Ora, se o patrão lhe paga R$100.00 por semana ( ou seja R$400.00 por mês conforme vimos) multiplicando-se esse valor por 52 semanas, temos – voilá ! – R$5.200.00 ! Surpresa surpresa ? Onde está portanto o 13 Salário ? A explicação é simples, embora os nossos conhecidos líderes trabalhistas nunca se tenham dado conta desse fato simples.

A resposta é que o patrão lhe rouba uma parte do salário durante todo o ano, pela simples razão de que há meses com 30 dias, outros com 31 e também meses com cinco semanas. Pagando-lhe mensalmente, portanto, esse patrão sabido se apodera de um dinheiro que não lhe pertence e isso porque o salário é o mesmo tenha o mês cinco semanas, trinta ou trinta e um dias e depois, com um sorriso de crocodilo lhe presenteia um décimo terceiro, dinheiro que saiu do próprio bolso do trabalhador. Por outro lado, não tenham meus 38 leitores nenhuma dúvida da precisão da informação que explico nesta matéria, pela razão elementar de que, em 1945 acompanhei de perto a habilidade política e matreira do meu falecido e simpático amigo, o deputado Aarão Steinbruck de Niteroi, que com essa gloriosa mentira conseguiu se eleger várias vezes. Daí que, como palavra final para meus inteligentes 38 leitores, ai estão as duas maravilhosas mentiras nacionais. Não caiam no conto do vigário. Não existe nenhum Décimo Terceiro. O patrão apenas lhe devolve o que sorrateiramente lhe surrupiou do salário anual. Que é o que explica porque, quando da votação do projeto Steinbruck, a lei foi aprovada rapidamente pelos patrióticos deputados a serviço da classe dirigente de então, que é a mesma que hoje comanda nosso delicioso Brasil.

Texto escrito por: Mario GiuDicelli
Publicado aqui.

Da física à informática! parte 3

2009-01-11T12:20:00.000-08:00

ps: elétrons são os vermelhos e o núcleo está em preto

A descoberta dos protons e eletrons(que ocorreu primeiro), foi uma revolução para a estrutura atômica.
E atualmente diz-se que os elétrons ficam do lado de fora do núcleo do âtomo, e os protons do lado de entro.

Os eletrons orbitam(giram em torno de) o núcleo do átomo em uma alta velocidade.

Bem, qualquer coisa que gira cria uma certa força sobre si que parte do centro do circulo imáginário formado pela rotação, para fora em direção ao objeto.

Essa força se chama força centrífuga... é a mesma força que empurra você contra os bancos do carrinho em uma montanha-russa quando está dentro de um loop.

A física é aplicada à todos os seres e objetos, inclusive aos elétrons.
Então se eles se mantém girando em uma órbita infinita.. o que os mantém dentro da orbita de um átomo?

Os prótons!

Os prótons dentro do núcleo "seguram" os elétrons dentro da sua órbita semi-constante.
Que não são completamente puxados para uma colisão com o núcleo por conta da força centrífuga.

Mas calma ae, protóns seguram os elétrons como?

Vamos entender isso, mas como a informação é bem chatinha mesmo, vou ficar por aqui..

Clique aqui para ler a continuação

Automação com CLP(controle lógico programável)

2009-01-05T18:22:00.000-08:00

Eu acredito que o CLP seja o dispositivo mais odiado da história industrial.
Sabe quando aquele chefe tem milhares de funcionários para colocar tampas em canetas, embalá-las e depois mada-las para à venda?

Bem, acontece que um dia, a procura aumenta.. o que significa que a oferta também precisa fazer o mesmo.
Mas como se os funcionários são limitados?
Contratar mais funcionários?

Contratar mais funcionários é uma tarefa delicada, porque não são só os funcionários que precisam ser contratados.
Você precisa calcular despesas, você precisa contratar chefes e supervisores para essa gente toda e além de tudo, mais funcionários significam, maiores riscos de acidentes de trabalho.

Nesse ponto, ele resolve trocar homens por máquina.. e é ai que muitos perdem seus empregos.

Uma máquina faz mais rápido, mais precisamente e com menores custos, qualquer coisa que um homem faça.
Isso é, qualquer trabalho físico.

Cabe então à nós; pensar, e à elas; fazer.

Quando chefe de uma empresa resolve trocar seus milhares de homens por uma única máquina automatizada, essa decisão tende à afetar muitas pessoas.
Mas também não é culpa d'ele que seus funcionários não se atualizem.

O fato é, quando não se pode vencê-las.. Junte se a elas.
Então, para quê batalhar com as máquinas em uma luta já perdida?
Apenas aprenda à controlá-las.

E é isso que você aprenderá nessa série.

Você não precisa só automatizar máquinas enormes, você pode automatizar qualquer circuito elétrico.
Até mesmo, os aparelhos eletrônicos da sua casa.
Rádios, televisões, tudo!

E aqui, você vai entender como.
Let's have some fun..

Da física à informática! parte 2, Conceitos Básicos.

2008-12-30T04:15:00.000-08:00

É, agora a parte pesada começa.
Nós vamos começar revendo alguns conceitos básicos que você deve ter aprendido na quinta ou sexta série do ensino fundamental.

Uma característica muito importante de qualquer animal, é a curiosidade.
Ela tem nos levado a lugares e descobertas.

Bem, uma das maiores curiosidades do homem, sempre foi saber do que algo é feito.
Se nós temos um muro, e o quebramos, nós descobrimos que ele é feito de tijolos.
Se quebrarmos os tijolos, descobriremos que eles são feitos de argila.

Mas a grande pergunta é, até onde podemos quebrar algo para encontrar sua matéria prima?
Será que existe um fim para esse processo?
Será que existe um ponto em que não se possa mais quebrar algo?

A resposta é sim e não.(?!)

O ÁTOMO

Os gregos foram os primeiros a admitir que existia um fim para esse ciclo.
Um ponto aonde um determinado objeto não poderia ser mais quebrado.
Uma particula única, indivisível(não quebrável) que seria a matéria prima de todas as matérias primas.(o0)
A partícula única comum a todos os seres.
Essa partícula(estrutura?) recebeu o nome de átomo.

O que eles propuseram foi que, tudo, absolutamente tudo, fosse feito de átomos.
Da lã daquela camisa feia que você ganhou de natal ao plástico do copo descartável cheio de cana-de-açúcar("caldo de cana") que você compra todo dia naquela pastelaria dos "chinas".
Até mesmo você!

"Leitor: Mas espera ai!
Leitor: Se tudo é feito de átomos, como tudo parece tão diferente?"

É ai que a química entra.

Vê aquela imagem ali em cima?
O átomo é teoricamente, a esfera central.

E as outras, o que são?
Para os gregos, naquela época, elas não existiam, somente o átomo central existia.
De fato, até meados do século 19, esse conceito perdurou até que admitiu-se a existencia de partículas menores ainda que o próprio átomo.

Essas partículas seriam entituladas: elétrons, neutrons e prótons..

Clique aqui para ler a continuação

Da física à informática! parte 1 - introdução

2008-10-20T09:00:00.000-07:00

Você já parou para olhar em volta?

O mundo muda e não é mais o que já foi.

Não, isso não é filosofia, é a realidade.

Uma realidade que se torna cada vez mais comum em nossas vidas, a tecnologia!

Neste momento eu mesmo estou escrevendo de um notebook.

Talvez você não tenha um notebook, mas deve ter uma televisão, um aparelho de dvd.. um celular?

Se sim, então você já faz parte do novo mundo em que as máquinas realizam e os homens pensam.

Mas você nunca parou para se perguntar como tudo isso pôde acontecer?

Como será que seu televisor funciona?

Como aquele programa em C++ que você codifica todo dia pode existir de verdade?

Não estou falando sobre kerneis de sistemas operacionais, nem tipos de memória.

Eu estou falando de algo mais profundo e antigo que a própria informática, que a tecnologia que nos rodeia... a física!

Sim, ela é a mãe de todas as ciências e nessa série você poderá aprender como a física gera a eletrônica, como a eletrônica gera a micro-eletrônica e como a micro-eletrônica gerou os primeiros computadores.

Você vai conhecer aonde tudo a sua volta se liga, de que forma sua televisão pode existir, de que forma você pode usar radio frequencias.

Mais do que aprender sobre a estrutura de um micro-processador é saber como ele é construído.

Já pensou em fazer robôs?

Nunca se perguntou como são feitos?

Eles também possuem micro-processadores, alguns bem parecidos com o que você tem em seu computador caseiro!

Nessa série, nós vamos quebrar as barreiras dos softwares e partir para um ponto em que tudo é possível.

Partiremos da física, exemplos eletrônicos, montar placas de circuitos, montar nossos mini-robos, manutenção de eletro-domésticos e por fim chegaremos na informática e então, você saberá como tudo isso foi possível, graças a pessoas capacitadas e autruístas.

Nós, como seres pensantes não precisamos ser subjulgados por nenhuma máquina, porque nós às criamos.

Saberemos o que um computador faz desde à sua essencia até o nosso software programado em uma IDE.

Clique aqui para ler a continuação

ShellCoding parte 3 > 3.2 Um novo debugger, um novo ponto de vista... o mesmo programa. > 3.3 A base dos Shellcodes

2008-10-19T10:15:00.000-07:00

O que me levou ao ollydbg foi a sua simplicidade... eu sou mais familiarizado com outro debugger, o windbg.
Apesar dele ser “mais complexo”, foi o primeiro que eu aprendi a mexer por influencia de alguns amigos, uma ótima influência.

O ollydbg é bem simples, mas nós somos machos certo?*coça o saco*
Então vamos mostrar como somos machos e que não temos medo de cara/interface feia e vamos aprender a mexer um pouco no windbg =]
Eu não me sentiria bem se passasse esse tutorial todo sem pelo menos fazer um “overview” do windbg... e aqui está ele.

O windbg é muito poderoso e é usado pelo próprio time de programadores da Microsoft entre outras coisas, para desenvolver o Windows!

Sim, ele permite a depuração de drivers e afins.

Algumas afirmações que eu fiz para vocês, foram bem mastigadas, muito mesmo.
Agora vamos usar esse debugger poderoso para complementar essas informações.

Ele é gratuito e você não terá que gastar nenhum centavo, apenas alguns minutos fazendo o download do pacote de debugging da Microsoft.
Onde encontrá-lo?
Aqui:
http://www.microsoft.com/whdc/DevTools/Debugging/default.mspx

Escolha a instalação com base na versão do SO que você tem(32 ou 64 bits).
Instale.

O pacote vem com entre outros aplicativos, o logger que é usado para identificar quais APIs um programa está usando, logview utilizado para visualizar os logs gerados pelo logger.exe ,KD que é um kernel debbuger e etc... por último mas não menos importante o windbg, o pacote também vem com outros debuggers user-mode application como o CDB mas não entraremos em detalhes.

Agora, abra o windbg na pasta que você instalou o pacote de debugging tools for Windows.
Você vai ter uma tela meio feinha de começo com somente a command bar à mostra.

O que você vai fazer é pressionar “CTRL + E” e abrir aquele assembly program que nós debugamos com o olly, se lembra?

Imediatamente ele nos mostra os módulos carregados e o estado dos registradores.(módulo é de certa forma só um outro nome para image file names(nome das “imagens” de arquivos /carregados/)

Existe um módulo em especial que sempre será carregado, é a DLL Kernel32.
Todos os programas que você tentar debuggar verá que essa DLL está presente.

Você quer saber por que isso te interessa?

Quando um processo é iniciado, o Windows cria um tipo de “header” para o processo.
Esse header se chama PEB(process enviroment block)¹.
Nele estão contidas todas as informações de um processo, inclusive os módulos carregados por ordem de loading.

Para nós, o conhecimento desse bloco é importante pois no Windows, nossos exploits precisam chamar APIs diferentemente de sistemas nix like que podemos chamar diretamente sys calls que estão sempre paradinhas la esperando por você, no entanto nós nem sempre sabemos o endereço em que uma DLL foi carregada e queremos que nosso exploit chame uma função da user32 por exemplo, o que fazemos?!

Bem como o kernel32 é sempre carregado e é um dos primeiros módulos carregados, ele está sempre no mesmo lugar dentro do PEB de um processo.

E esse módulo tem duas APIs importantíssimas para podermos usar qualquer uma que quisermos... São as LoadLibrary* e GetProcessAdress* que respectivamente carregam um módulo e pegam o endereço de uma API contida nele.

Mas você ainda não vai construir um exploit agora... só que a partir de agora, as informações que antes eu disse que foram “filtradas/mastigadas” não serão mais tão mastigadas, então se prepare para uma enxurrada controlada de nomes estranhos aparecendo na sua tela. =P

¹:http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Process/PEB.html

Voltemos ao Windbg com nosso tuto.exe carregado, aperte “ALT + F7” para ver o disassembly.
E repare em uma coisa, nós estamos antes mesmo do programa começar, esse não é o código do nosso processo!
Então cadê ele?

O Windows ainda está por chamar o nosso programa mas se quisermos encontrar aonde começa o código dele é simples... vamos encontrar o entry point do módulo tuto.exe.

Entry point é basicamente aonde o código do programa começa, ele denota a parte do image file para o qual nós iremos dar um long jump, ou seja, a primeira função executada de um determinado processo.
Hoje em dia é normal que os programas só tenham um entry point, por exemplo o int WinMain() que nós vemos todo dia em nossos programas win app C++/C.

Image File ou imagem do arquivo, é a imagem que é criada na memória de um determinado arquivo.
Quando você executa um determinado programa, por exemplo, o nosso tuto.exe, o Windows copia ele todo para a memória, essa cópia ganha o nome de image file.

Mas não para por ai, não pense que memória é sinônimo de memória RAM física não.

Cada processo tem uma determinada quantidade de memória que é chamada de memória virtual.
Essa memória virtual é endereçável(lógico) mas o seu endereço é relativo, ou seja, nem sempre corresponde ao endereço REAL na memória física.
Isso quer dizer que uma variável de um programa pode estar claramente no endereço 0x0012ffaa, outro programa ter uma variável no mesmo endereço e no entanto, elas podem sim ter valores diferentes... isso porque os processos(normalmente) não compartilham sua memória virtual com outros, eles podem ter claramente o mesmo endereço virtual, sendo que o endereço virtual é mapeado(transformado) para um físico no momento de execução do processo.
Cada processo pode ter até 2GB de memória virtual, mas nem toda ela é alocável, parte é reservada pelo sistema e os endereços vão de 0x00000000e16 à 0x7FFFFFFFe16.(‘e16’ é notação científica)

Lembra-se que eu disse que a stack poderia chegar ao endereço 0x00 e o sistema falaria que falta memória?
Aquilo ajudou a entender que a memória cresce do maior endereço para o menor, mas eu coloquei aquele “hipoteticamente falando” justamente porque isso não é possível, o endereço virtual 0x00 é reservado para o sistema e se sobrescrito possivelmente quebra o programa.
E sim, no win32 a stack faz parte da memória virtual de um processo e hoje em dia tem fronteiras bem definidas ao contrário das suas antigas versões.

O mundo era mais bonito quando o céu só podia ser azul não é?

Mas a vida real não é assim e as coisas são mais complicadas do que isso, então se concentre e não perca o foco porque eu ainda não comecei a parte mais complicada.

Aprendemos o que é o entry point, então vamos achá-lo?

O windbg vem com várias extensões muito úteis e vamos usar uma delas.
Na command bar digite “!dlls”.
Pronto!
Agora você está vendo informações específicas dos módulos carregados.

E está ai também o entry point do tuto.exe certo?
Então já sabemos seu endereço(401000), vamos colocar um breakpoint nesse endereço e mandar o windbg deixar o programa correr livre leve e solto até encontrar o que nós queremos.

Digite .cls para limpar a tela(so fresco mesmo =P)
Agora digite:

BP /1 401000 “.echo =============|| ENTRY POINT ||=================” [enter]

BP, seta um breakpoint.
/1 diz que assim que esse break point for executado uma vez, ele será deletado.
401000 é o endereço.
O que segue entre aspas é o comando que será executado quando esse breakpoint for encontrado.
No nosso caso, o echo vai exibir a string “...ENTRY P...” na tela.

Se aparecer o status “busy” ao lado da command bar, espere até o status voltar ao normal.

Agora digite ‘g’(sem aspas) que significa “oh baby, let’s Go” ou só “GO” se você preferir. =P

Ele vai rodar e vai para justamente aonde começa o nosso código tão conhecido. =]

(posteriormente você poderá substituir essa ação toda por "g @$exentry")

3.3 A base dos Shellcodes.

Novo capítulo, mas nós vamos continuar com aquele nosso debugger(windbg) e no ponto aonde paramos, mas desta vez, a idéia não é explicar o que vai acontecer com o programa e sim entender talvez o último ponto necessário para começarmos a construir nossos exploits.

Só para recapitular:

A primeira coisa que quero que você faça após encontrar o entry point de tuto.exe é apertar f10, o debugger vai dar uma “passo” a frente colocando 00000008 na stack.
Ok, isso nós já sabemos.
O windbg já mostra o estado dos registradores, a próxima instrução a ser executada e etc, normal.

Vamos agora fazer um dump ou seja, ver o valor que está em certo local da memória virtual do nosso processo.

A função ‘d’ do windbg é responsável por fazer o dump da memória virtual de um processo.
Ela funciona com diferentes tamanhos.
Por exemplo, se você escrever ‘db *endereço*’ ela vai te mostrar o dump hexadecimal em bytes(8 bits) do endereço desejado.

Bem, nós sabemos que esp aponta para o topo da stack certo?
Então como nós já sabemos que o 0~8 já deve estar na stack, vamos ver essa função em ação passando para ela o endereço que está em esp.

Digite ‘dd esp’ e logo você verá isso:
0012ffa0 00000008 76373833 7ffdd000 0012ffec
0012ffb0 77a5a9bd 7ffdd000 00129e72 00000000
0012ffc0 00000000 7ffdd000 00000000 00000000
0012ffd0 00000000 0012ffb8 00000000 ffffffff
0012ffe0 77a28bf2 77a69096 00000000 00000000
0012fff0 00000000 00401000 7ffdd000 00000000
00130000 78746341 00000020 00000001 00003008
00130010 000000dc 00000000 00000020 00000000

Percebe o 8 no topo?
Repare que dd faz ele exibir em Double words ou seja, de 32 em 32 bits ou 8 caracteres hexadecimais/4 bytes.

Repare também que ele exibe 5 colunas, a primeria é o endereço do valor da segunda coluna na memória vitual do processo.

Nós podemos obrigá-la a exibir apenas uma coluna, assim:

‘dd /c 1 esp’
Assim nós visualizaremos como se estivéssemos no ollydbg, de quatro em quatro bytes e seus respectivos endereços ao lado.

0012ffa0 00000008
0012ffa4 76373833
0012ffa8 7ffdd000
0012ffac 0012ffec
0012ffb0 77a5a9bd
0012ffb4 7ffdd000
0012ffb8 00129e72
0012ffbc 00000000
0012ffc0 00000000
0012ffc4 7ffdd000
0012ffc8 00000000
0012ffcc 00000000
0012ffd0 00000000
0012ffd4 0012ffb8
0012ffd8 00000000
0012ffdc ffffffff
0012ffe0 77a28bf2
0012ffe4 77a69096
0012ffe8 00000000
0012ffec 00000000
0012fff0 00000000
0012fff4 00401000
0012fff8 7ffdd000
0012fffc 00000000
00130000 78746341
00130004 00000020
00130008 00000001
0013000c 00003008
00130010 000000dc
00130014 00000000
00130018 00000020
0013001c 00000000

Nós podemos visualizar de byte em byte ao invés de 4 em 4 como antes.
Usando o db como foi dito antes e podemos ainda mais, podemos dizer apartir de qual endereço da memória nós queremos ver e até qual.
Assim:
‘db esp esp+3’
0:000> db esp esp+3
0012ffa0 08 00 00 00

Ou seja, ele vai exibir esp(12ffa0) até esp+3(12ffa43) em outras palavras ele vai exibir o
12ffa0
12ffa1
12ffa2
12ffa3

Ou seja, um double Word(4 bytes) só que de byte em byte.

Agora, se lembra que eu falei que as instruções asm são representações para os opcodes¹ e que esses sim é que rodam e fazem algo?
Bem, o programa já foi compilado e esses opcodes já estão na memória virtual do processo, o disassembly só reconverte esses opcodes para código asm novamente o que não é nada difícil.

¹: tem um tuto mto bom que explica como são feitos, ele foi feito pelo alucard e está aqui>http://alucard.dxs.googlepages.com/Tutorial_OpCode.html

Bem, se esses opcodes estão no endereço em que vemos o disassembly, então nós podemos “ripalos”.
Ou seja, nós podemos ver quais são esses opcodes e colocar em outro programa.

Vamos dumpar todo o código do nosso tuto.exe.

Digite ‘dd 401000 40100b’

401000 é o endereço do entry point do nosso módulo como já vimos, e 40100b é o endereço da sua última instrução(ret).
A saída desse dump é:
00401000 ffb9086a 49ffffff c358fd75

A primeira coluna é um endereço como já sabemos e as 3 seguintes são o dump dessa área da memória.

Se lembra que nosso programa põe o 8 na stack e depois o coloca em eax?
Se lembra que eu também disse que eax é usado para retornar valores de funções.

Logo, imagine esse código:

int soma()
{
int eax = 8, ecx = 0xFFFFFFFF;
for(;ecx>0;ecx--);
return eax;
}

Pois bem, o nosso programa é a completa representação desse código C.

Ele põe 8 na stack, cria um loop de 0xFFFFFFFF até 0x00(uma espécie de delay hardcoded) põe 8 em eax e ret retorna para o ponto aonde o processo chamador parou tirando da stack o endereço pra próxima instrução e colocando em eip, como eax é usado para retornar valores e resultados de funções então logo a nossa função retorna um número, o 8.

Bem, nós já temos os opcodes, que tal colocarmos ele em um programa e ver se roda?

Bem, vamos primeiro visualizá-lo como um programa C completo:

#include stdio.h

int soma()
{
int eax = 8, ecx = 0xFFFFFFFF;

for (;ecx > 0; ecx--);

return eax;
}

int main()
{
printf("Valor: %d", soma() );

}

Isso nós já sabemos né?

Então que tal colocarmos aqueles opcodes e ver se tem o mesmo resultado?

Vamos fazer isso, repare que temos 3 colunas de 4 bytes de dados.
4 bytes = int

Então vamos criar um array de 3 int’s e vamos forçar o nosso programa C a chamá-lo como se fosse uma função...

Primeiro vamos copiar essas 3 colunas de opcodes e transformar em um array de ints.

int OpCodes[] = {0xffb9086a, 0x49ffffff, 0xc358fd75};

Veja que eu coloco o ‘0x’ na frente para o compilador saber que são valores hexadecimais.

Agora que nós temos o tal array vamos forçar o compilador a chamá-lo como uma função que retornar um inteiro:

((int (*) ())OpCodes)()

Não se assuste, olhe por um lado, nós temos o array OpCodes.

Vamos usar um cast de uma função que retorna um inteiro n’ele:

( int (*)() ) <- esse é o cast

Envolvemos o cast e o endereço do primeiro elemento de Opcodes entre parênteses:

((int) (*) ()) OpCodes)

E agora que já o transformamos em uma função que retorna um inteiro, vamos chamar essa função:

((int) (*) ()) OpCodes) ()

Bem, vamos colocar isso tudo num printf para que ele exiba o valor 8:

#include stdio.h

int main()
{
int OpCodes[] = {0xffb9086a, 0x49ffffff, 0xc358fd75};

printf("Valor: %d", ((int (*) ())OpCodes)() );

}

Vê?!

Alguns preferem fazer a mesma coisa só que com uma string.

Strings em C são simples arrays de bytes... isso significa que nós iremos ter que colocar um ‘\x’¹ para cada byte(2 dígitos hex), no final o resultado é o mesmo, a diferença é quem escreve mais:

#include

int main()
{
int OpCodes[] = {0xffb9086a, 0x49ffffff, 0xc358fd75};

char szOpCodes[] =
"\x6a\x08\xb9\xff"
"\xff\xff\xff\x49"
"\x75\xfd\x58\xc3";

printf("Valor: %d", ((int (*) ())szOpCodes)() );

}

Repare que eu só adicionei um ‘sz’² e troquei a ordem dos bytes.

Você já vai saber o porque dessa ordem trocada... mas por hoje é só, cya. =]

¹: indica que o próximo byte não deve ser interpretado como caracter
²: notação húngara indicando uma string terminada em zero.

ShellCoding parte 3 - Primeiros passos rumo ao shellcoding > 3.1 primeiro programa assembly

2008-10-19T08:27:00.000-07:00

Essa seção apresenta duas ferramentas importantíssimas para quem quer encontrar vulnerabilidades; o assembler e o debugger.

Nessa seção também, nós aprofundaremos o conhecimento que você adquiriu da linguagem assembly, só que dessa vez, usando a prática para entender como, por exemplo, a stack funciona.

De começo, usaremos o MASM32 como assembler.

O MASM32 pode ser encontrado em:
http://www.masm32.com/
E o ollydbg é o primeiro debugger que vamos usar e pode ser encontrado em:
http://www.ollydbg.de/download.htm

Um assembler é uma espécie de compilador da linguagem assembly que passa as instruções asm para o código de máquina enquanto que um debugger também chamado de depurador, roda um programa deixando-o ver cada instrução executada pelo programa passo-a-passo.

3.1 Primeiro programa assembly

A partir de agora, as práticas serão mescladas com a teoria e a primeira parte da prática é bem simples e nos ensinará o funcionamento da stack.

Para começar, abra seu MASM32, e insira o seguinte código:
.386
.model flat, stdcall
option casemap:none

.code
start:

push 8

mov ECX, 0FFFFFFFFh

lg:
dec ECX
jnz lg

pop EAX

ret
end start

Vamos entende-lo por partes.

.386 indica qual intruction set¹ iremos usar, nesse caso, o do 80386 mesmo.

¹: podemos encontrar o instruction set da família x86 em:
http://en.wikipedia.org/wiki/X86_instruction_listings
http://home.comcast.net/~fbui/intel.html
http://www.x86.org/intel.doc/386manuals.htm

.model flat, stdcall: você entenderá mais tarde...

.code: indica o início do código do programa...

start: é a label que indica todo o corpo do programa.

end start: é aonde ele termina, tudo o que iremos escrever ficará entre esses dois.

Na verdade, todas as funções que chamamos, são labels que indicam o offset(deslocamento) da próxima instrução a ser executada..

Agora clique em assemble & link como na imagem->

Agora o que nós vamos fazer, é abrir o ollydbg, clicar em File>Open e no binário gerado(tuto.exe no meu caso) e poderemos ver o código gerado por ele em ação passo a passo.(apesar de estar usando ele, eu recomendo o SoftIce, Windbg ¹ e o IDA Pro como disassembler no entanto não vou ter tempo de lhes ensinar como usar todos... na verdade, em breve mostrarei como criar suas próprias ferramentas, o que é bem melhor do que contar com softwares que quase sempre deixam a desejar diante das suas necessidades e tem bugs que são largamente explorados por aplicações cujos donos não querem que sejam ‘debugadas’)

¹: Recomendo a leitura desse blog> http://www.1bit.com.br/content.1bit/windbg1
O que termos é uma imagem parecida com a seguinte:

A área marcada com o número um contém o disassembly do programa, que é o código assembly gerado por um compilador comum ou assembler, como nós fizemos o programa em assembly o código é igual ao que nós fizemos, no entanto se fosse outra linguagem de programação, nós veríamos um código assembly gerado muito maior, principalmente depois do processo de “linkagem”.
A coluna “address” indica o endereço virtual de cada instrução asm.
A coluna hex dump nada mais é do que a coluna disassembly traduzida para os códigos operacionais que são o que o compilador realmente entende.

Comment, é a coluna aonde os comentários ficam, muitas vezes o próprio olly vai lhe fornecer comentários para dizer por exemplo, que certa operação é a passagem de parâmetros para uma função determinada.

A área 2 é basicamente a janela da CPU aonde você pode ver o estado de diferentes registradores.

A área 3 é a stack.
A stack é basicamente uma área da memória para acesso rápido.
O processador é otimizado para acesso à pilha, portanto ela não é como o resto da memória virtual de um processo.
Ela cresce de 32 bits em 32 bits.
No Windows ela tem a peculiaridade de estar armazenada em endereços baixos o que é prejudicial(não tanto) para construirmos nossos shellcodes.

Ela tem outra peculiaridade que é crescer de cima para baixo e quando removemos algo dela, removemos primeiro o que está em cima.

Veremos isso daqui a pouco na prática.

A área 4 é a RAM do processo, nesse tuto não veremos muito sobre essa janela.

Agora voltemos ao nosso ollydbg.
Ele é um debugger o que significa que podemos executar cada instrução de um determinado programa e ver o que acontece na íntegra com os registradores, a stack e etc.

Então o que vamos fazer é apertar F7 para que a primeira instrução seja executada.(push 8 )
O que essa instrução faz, é colocar um valor na stack, no nosso caso o 8.

A stack cresce de cima para baixo como eu disse, um novo valor é sempre posto no topo dela e o que vemos em vermelho, é que em primeiro lugar, o valor antigo da stack ficou abaixo do novo que nós colocamos(00000008) e em segundo lugar, ainda em vermelho, podemos notar que o endereço do valor da stack desce 4 bytes(de 0012FFA4 para 0012FFA0), isso se deve pelo fato de que o maior endereço que a stack pode alcançar, é zero.(na verdade não é assim, mas vamos adotar o topo como sendo o zero para que seja mais fácil de entender como os maiores valores positivos sempre estão em baixo)

Ou seja, ela crescerá para baixo e seu topo será o zero.. quando você usar o suficiente dela para chegar no 0, seria hipoteticamente falando, a hora que o Windows diria que falta memória.(na verdade, o que acontecia nos tempos do 9x é que se podia ultrapassar os limites da stack e o que acontecia realmente era que o windows normalmente "quebrava" por corrupção de memória)

Vemos em roxo também(voltando para a figura anterior), que os registradores que sofrem alguma mudança, o olly os realça em uma cor vermelha(pode mudar de acordo com suas configurações).
Os registradores que mudaram com a instrução ‘push 8’, foram o EIP e o ESP.

O ESP nós sabemos que aponta para o local aonde nós queremos que seja o topo da stack.
E como podemos ver, o seu valor na janela da CPU é 0012FFA0, exatamente o endereço da área onde está o nosso 00000008.
Quando PUSHamos um valor para a stack, o ESP é decrementado em 4.

O outro registrador que mudou de valor, foi o EIP.
EIP é o registrador que aponta para a próxima instrução a ser executada.
Como podemos ver, a próxima instrução está em abóbora e seu endereço é o mesmo que o do EIP.
O EIP é automaticamente atualizado pela CPU para apontar para a próxima instrução e ele não pode ser mudado por instruções como mov.
EX:
mov EIP, 00401002h -> errado
(reparem também que quando eu quero escrever algum número hexadecimal, eu coloco o terminador ‘h’, caso o número já comece com alguma letra, eu tenho que por um zero antes para que o assembler possa distingui-lo de uma variável.(ex: 0DEADBEEFh)

O que vamos fazer é apertar f7 novamente para seguirmos um passo à frente.
Vemos que ele move o valor 0FFFFFFFFh para ECX(como nós já vimos, -1 corresponde ao maior número hexadecimal que uma variável pode alcançar)
Podemos ver que ECX e EIP são realçados por terem sido mudados, ECX com o valor movido e EIP com o endereço da próxima instrução.

Se você também olhar para o hexdump da instrução mov ECX, -1... poderá ver o valor 0FFFFFFFFh sendo movido para ECX(B9 <- código operacional, FFFFFFFF <- valor)

A próxima instrução, “DEC ECX” decrementa ECX em um. Não tem nenhum mistério nisso.

Mais um passo e damos de cara com um JNZ. JNZ significa jump if not zero, ou seja, pule se não for zero.

Ele vai pular para um determinado endereço se a operação anterior não resultou em zero.

Ou seja, o que esse bloco vai fazer(DEC ECX && JNZ 401007), é decrementar ECX até ele chegar a zero.

Quando ele chegar, o jnz não será executado e poderemos passar para a próxima instrução.

Bem, você pode segurar o F7 até ECX chegar a zero e ficar olhando o EIP mudar freneticamente... ou pode simplesmente clicar duas vezes no ECX, mudar seu valor para zero, dar enter e seguir para a penúltima das nossas instruções.(faça isso quando estiver para executar o jnz, não antes ou o valor voltará para -1)

A penúltima das nossas instruções é a pop EAX. POP simplesmente pega o valor para o qual ESP está apontando(valor da stack), e põe no registrador indicado. Se lembra que nós tínhamos posto o valor 8 na stack com push?

Push decrementou ESP 4 bytes e colocou o 8 na pilha(stack). Pop vai realizar justamente o contrário... ele incrementará ESP em 4 bytes e vai colocar o valor 8 em EAX. Aperte F7 e veja isso acontecer... EAX passa a conter o valor 8.

No entanto, o valor 8 não é apagado da stack, ele continua lá muito embora ESP não aponte mais para ele... isso se deve ao fato de que pop não grava na stack, ele simplesmente à lê.

E finalmente chegamos a nossa última instrução... Retn.

Lembra-se que eu falei que EIP não pode ser modificado diretamente? Mas nós já vimos uma instrução que modifica EIP, a JNZ.

Retn/ret é outra instrução que modifica EIP. O que acontece, é que sempre que uma função é chamada, o valor da próxima instrução após essa função é guardado na stack.

Retn funciona como um pop só que específico para EIP, ele pega o valor apontado por ESP e o põe em EIP. É assim que o programa sabe para onde voltar de uma determinada função. Imagine essa situação:

void Func() { }

Int main() {

Func();

return 0;

}

Nesse caso, quando Func é chamada, a endereço de “return 0” é guardado na stack, assim o programa sabe para onde deve seguir após a função interna ser executada por completo.

Clique aqui para ler a continuação

ShellCoding parte 2 - asm básico > 2.2 Introdução ao assembly > 2.3 instruções ASM

2008-10-18T08:54:00.000-07:00

Muitas linguagens nascem e morrem.

Object pascal há um tempo, era uma linguagem exemplarmente fácil e perfeita para o ambiente industrial o que a disseminou pelos quatro cantos do mundo.
Hoje ela se torna ofuscada por linguagens relativamente novas como o JAVA.
Isso se dá, porque a facilidade de programar em alto nível aumenta de forma vertiginosa... obj pascal perde para esse novo tipo de linguagem na facilidade, na portabilidade e até na segurança(já que o tipo do qual estamos falando, são os type safe)... e se Java não puder fazer algo que o pascal possa, certamente o C Sharp poderá com a vantagem de também ser type safe.
No entanto, a dificuldade de se programar em baixo nível nunca mudou e nós sempre iremos precisar nos comunicar com a máquina na linguagem dela.(depois do ASM, é claro que antes era de outra forma)
Sempre precisarão de alguém que ponha a “mão na massa” e “faça acontecer”.(duas figuras de linguagem em uma única frase curta o0 )
As linguagens de alto nível vão morrer, talvez nem todas, mas sofrerão mudanças... no entanto nosso bom e velho assembly continua ai, com seus 58 anos de idade e eu realmente duvido que seja um dia substituído simplesmente porque “panela velha é que faz comida boa”... Boa e rápida, diga-se de passagem.
Assembly é a linguagem mais rápida e não é à toa...
Assembly é uma simples representação dos códigos operacionais.

Esses opcode’s(códigos operacionais) são a verdadeira linguagem dos microprocessadores.. no entanto como programar usando números seria algo desumano o assembly foi criado para suprir nossas necessidades.

Bem, para aprender assembly , existem alguns conceitos básicos pelos quais devemos passar.
O primeiro deles é o tamanho básico que alguns dados ocupam na memória.
O computador sabidamente trabalha com o sistema binário, o sistema binário varia de 1 a 0.
Essa comunicação dá-se pela tensão(força que impulsiona os elétrons).
Como eu não consegui achar o esquema na internet; os dados que eu irei passar são imprecisos já que se baseiam na minha memória. (ela só armazena 12kb =P)
De 0 volts a 1,4 é a zona morta e seu valor lógico é zero.
De 1,5 a 3,0 é a “zona de indecisão” em que basicamente o valor lógico pode ser um ou zero dependendo de que parte do circuito nós estamos.
E de 3,0 a 5,0 é a zona ativa aonde o valor lógico é um.
Para definir um padrão, nós adotamos que o valor da zona morta é sempre com a tensão zero e o da zona ativa sempre com a tensão em 5,0 v.(a zona de indecisão não é importante para nós)
O importante é perceber que apesar da tensão poder ter pequenas variações, o importante é o valor lógico ao qual ela está atrelada.

Bit significa binary digit ou dígito binário e por ser binário pode variar entre um ou zero.
Quando nós temos quatro bits juntos, nós temos um nibble.( de 0000 a 1111 )
Oito bits juntos são um byte.(de 00000000 a 11111111)
Dezesseis bits juntos ou 2 bytes são um Word(de 0000000000000000 a 1111111111111111)
E um Double Word são 32 bits ou 4 bytes.(não me peça pra escrever 64 bits aqui ¬¬)

O segundo conceito básico são as operações lógicas.
A maioria das operações lógicas tem dois operandos como as matemáticas(1 + 1)
A diferença fica por conta do resultado gerado.

A primeira operação lógica que nós iremos ver é a operação denominada AND.
And na língua portuguesa significa ‘E’, e ela compara o primeiro operando com o segundo... se ambos forem 1 logo sua saída/resposta será um, qualquer coisa diferente disse recebe o valor zero.
Vejamos sua utilização:
AND 1, 1 ; saída 1
AND 1, 0 ; saída 0
AND 0, 1 ; saída 0
AND 0, 0 ;saída 0
No mundo da eletrônica em geral(obviamente incluindo a informática), existe o que chamamos de tabela lógica, nada mais é do que uma representação do que vimos aqui mais arrumado e graficamente.

| B | A | S |
0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

Nós temos os operandos( A & B ) e o resultado da operação/saída( S ) e abaixo, todas as possibilidades de valores que esses operandos podem assumir e as saídas que eles irão produzir.

Apesar das portas lógicas físicamente poderem ter mais do que duas variáveis, no assembly nós quase sempre as veremos com dois operandos.(pelo fato de quase sempre estarmos trabalhando com 4 bytes de informação)

A operação lógica OR, tem a saída 1 se uma das variáveis for também um.
| B | A | S |
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

A operação lógica XOR opera como a OR com a exceção de que ela só retorna um na saída se apenas uma das variáveis for um.

| B | A | S |
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0 <- reparem no zero quando as duas variáveis são um Agora vamos entender o complemento de dois, muito usado em flip-flop’s pra que vem da eletrônica. Nós já aprendemos como os números decimais podem ser representados na base binária. Agora vamos entender como máquinas representam números decimais negativos binariamente(já que não existe – 0001 e + 0001) Imaginemos um nibble, ele pode representar até o número 15(1111) em decimal. No entanto, para que ele represente negativos e positivos, ele deverá ser dividido ao meio. Como temos um nibble, números de 0000 a 0111(7) serão positivos... Os números negativos possuem o último bit como o valor 1. Fazendo uma tabela: Dec |Bin -8 > 1000
-7 > 1001
-6 > 1010
-5 > 1011
-4 > 1100
-3 > 1101
-2 > 1110
-1 > 1111
0 > 0000
1 > 0001
2 > 0010
Isso segue até o sete(0111).
Para se adquirir um número negativo correspondente ao seu positivo, usa-se o complemento de dois, ele possui uma fórmula mas na verdade tudo o que você tem que fazer é inverter todos os bits de um número e somar 1 à ele.
Ex:
0111(sete)
1000(-8) + 1
1001(-7)

Como um nibble só tem 4 bits, então:

0111 (7)
+
1001(-7)
____
10000

Repare que 1+1 = 10(dois em binário) e você faz aquela velha operação do “vai um” decimal.
A resposta é 10000, mas como tem 5 bits a resposta e estamos falando de uma variável que só possui quatro, o último bit é descartado e ficamos com a resposta 0000 que é o resultado correto.
Simples né? =]

Como eu estou correndo MESMO, vou pular alguns temas muito importantes para que você aprenda definitivamente essa linguagem tão impressionante.

A CPU trabalha através de certos registradores, esse registradores são como as variáveis que nós usamos nos nossos exemplos de portas lógicas, eles armazenam uma certa quantidade de bits(8, 16, 32 e 64)..
Vamos conhecer os registradores que nós mais veremos durante a vida útil desse tutorial.
A maioria dos registradores podem ser divididos em 4 partes.
Por exemplo o EAX(o nome do registrador é AX, o ‘E’ antes dele significa ‘extended’)
Um registrador Extended tem 32 bits no entanto ele também pode ser acessado como um registrador de 16 e 8 bits.
Veja por esse lado, EAX tem 32 bits
EAX pode ser dividido em EAL(‘L’ de LOW/Baixo) 16 bits e EAH(‘H’ de high/alto).
Ou seja, os 16 bits mais baixos e os 16 mais altos.
Eles ainda fazem parte de EAX, mas você pode acessar as partes de EAX separadamente se quiser.
Por sua vez, EAX pode ser acessado como AX como um registrador de 16 bits que também pode ser dividido em AL e AH cada um tendo 8 bits.(note que EAL é igual a AX)

EAX é um registrador de propósito geral o que quer dizer que ele logicamente pode ser usado de diversas maneiras para guardar qualquer tipo de dado... No entanto a prática não é assim. (devido á certas leis que não são imutáveis mas que são seguidas a risca por muitos assemblers)

EAX é um registrador importante, ele é usado para passar dados para uma função ou retornar esses dados de certa função, as APIs do Windows retornam HANDLES, ponteiros, estruturas e etc.
Tudo por ele.
Ele também é usado para ler e receber dados da memória(por ser um pouco mais rápido para isso que os outros)

EBX é muito usado para endereços de memória.

ECX como contador para instruções de loop.(não é regra e ás vezes é até usado como auxiliar do EAX o0)

EDX é o auxiliar do EAX oficial, se o EAX estiver em uso, então esse registrador armazenará o os dados por EAX.

Um resumão>
AX- acumulador
BX- Base
CX- contador
DX- dados
Todos esses apresentados podem ser divididos como registradores de 8, 16 e 32 bits...
Os próximos registradores que vou lhes apresentar, também são de uso geral no entanto como esses, vocês irão perceber que não são de uso “tão geral assim”.

ESI & EDI: esses dois registradores são quase sempre usados como source e index(fonte e destino) para operações envolvendo strings mas também são usados sempre que se precisa ler e escrever em uma área da memória.

ESP: Mantém o endereço do topo da stack(mais tarde veremos um pouco sobre ela)

EBP: Normalmente armazena o endereço da base de um stack frame, nós o veremos muito em prólogos e epílogos de funções.(não se assuste, o nome é estranho mas logo não será mais)

Esses registradores podem ser divididos entre 16 e 32 bits, sendo os de 32 bits os que possuem o prefixo “E”(ESP) e sem o prefixo os de 16(SP).

2.3 Instruções ASM

Todas as operações do assembly são processor-dependent¹... não importa se você está programando para um micro-controlador ou em um pc comum, o set de instruções que um micro-processador aceita é designado de fábrica e você pode ler o “instruction set”² no site do fabricante.

¹: dependem diretamente do processador
²:Também referido como instructions table e por ai vai

A primeira função que veremos é a mov.
Mov, movimenta dados da origem(primeiro operador) para o destino(segundo operador).(isso muda na sintaxe AT&T, mais tarde eu farei um pequeno tuto sobre ela, no momento, nos focaremos na intel)

É como se fizéssemos isso:
“int EDX, EAX = 1;
EDX = EAX;”

Por exemplo, vamos usá-la com os registradores edx e eax.

mov EAX, 1 ;EAX = 1

mov EDX, EAX ; EDX = EAX

Reparem que tudo depois do caracter ‘;’ é uma linha de comentário diferentemente do C que usa os caracteres “/*” e “*/” ou “//”

Outro conjunto de instruções, são as portas lógicas que lhes ensinei.

XOR, faz a operação XOR(exclusive or, ou exclusivo) bit a bit em dois operandos e o resultado é guardado no primeiro operando.

Ex:
mov AL, 1 ; AL = 0000 0001
mov AH, 2 ; AH = 0000 0010
xor AL, AH ; AL = 0000 0011

xor é muitas vezes usado para zerar um registrador, por exemplo:

mov AX, 512 ; AX = 0000 0010 0000 0000
xor AX, AX ; AX = 0000 0000 0000 0000

Como o xor é o “ou exclusivo” e só retorna um se somente um dos bits for 1, a operação entre dois valores exatamente iguais sempre dará zero.

Lembre-se que ax contém 16 bits e AL e AH somente 8.

OR faz a operação OR(ou) bit a bit em dois operandos.
mov AX, 512 ; AX = 0000 0010 0000 0000
or AX, AX ; AX = 0000 0010 0000 0000

AND, uso:

mov AL, 15 ; AL = 0000 1111
AND AL, 4 ; AL = 0000 0100

INC, incrementa um operando em um:

mov AL, 0 ; AL = 0000 0000
inc AL ; AL = 0000 0001
inc AL ; AL = 0000 0010

DEC, decrementa um operando em um:

mov AL, 2 ; AL = 0000 0010
dec AL ; AL = 0000 00001
dec AL ; AL = 0000 0000

IMUL, multiplica dois operandos guardando o resultado no primeiro:

mov AL, 2 ;AL = 0000 0010
mov AH, 2 ; AH = 0000 0010
IMUL AH, AL ; AH = 0000 0100
; AX = 0000 0100 0000 0010
AH AL

Você ainda não conhece assembly o suficiente após ter lido isso, mas essa parte de assembly básico já está concluída, no entanto nós sempre veremos um pouco de assembly no decorrer do tutorial.

Eu escolhi essa organização porque por experiência própria, eu sei que uma aprendizagem dinâmica é melhor do que algo estático.(é sempre bom quando seu professor de matemática usa um pouco de outra matéria para desviar do assunto principal e lhe ensinar matemática de uma forma mais alternativa sem uma abordagem tão direta.)

Clique aqui para ler a continuação

Um papo sobre algoritmos criptográficos de hashing, parte 1

2008-10-17T09:27:00.000-07:00

Algoritmos criptográficos de hashing são a grande base das assinaturas digitais hoje em dia.

Um algoritmo de hash criptográfico, codifica uma tabela de dados sendo essa tabela/vetor um texto ou qualquer outro tipo de dado.

Essa codigicação dá-se através de cálculos matemáticos e no final do "hashing", não importa o tamanho do dado codigicado, ele terá um tamanho prédefinido, sempre.

De fato, na teoria, como temos um tamanho fixo na saída do algorítmo criptográfico, o que um hash deveria fazer seria evitar colisões(quando duas entradas diferentes geram um mesmo hash).

Mas justamente pelo fato de termos um número de possibilidades de saída limitado, evitar colisões fica impossível mas o que realmente um desenvolvedor de um algoritmo criptográfico de hashing quer, é que essas colisões sejam impossíveis de se achar intencionalmente.

Um dos "hash algorithms" mais utilizados é/foi o hash MD5 feito em 1992 substituindo o seu predecessor MD4.

Os hashs são famosos por serem "one-way" ou seja, você pode encriptar um determinado dado mas é impossível de desencriptá-lo.

Então o que torna um algoritmo de escrutínio(hashing) seguro ou inseguro?

São exatamente essas tais de colisões...

Quando podemos achá-las intencionalmente as possibilidades se tornam inimagináveis já que hashs são usados por exemplo, para verificar a integridade e autenticidade de um executavel.

A um tempo atrás, um exemplo de ataque em que dois executaveis tinham a mesma assinatura de hashing foi publicado.

Nele, apesar de ambos os arquivos terem a mesma assinatura de hash, um era comum e outro extremamente malévolo.

Desde 1994 técnicas para encontrar colisões no MD5 vem sendo largamente descobertas e publicadas, até que em 2004 o MD5 foi quebrado.

Nesse contexto nós temos uma grande falha de segurança por falta de algoritmos de escrutínio descentes.

Ronald L. Rivest então apresenta seu mais novo hash, o MD6.

Podendo usar até mais processadores para diminuir a demora para gerar um hash.

Um algoritmo robusto e complexo o que teoricamente o torna seguro.

O problema é que ele é inviável.

Sua complexidade o torna dificil de ser implementado e principalmente, o torna caro e nada sustentável.

Então o que nós vamos fazer ao longo desse "papo sobre hashing" é dar um pontapé em um algoritmo de hashing mais viável e poderoso.

Eu gosto de me impor desafios para aumentar as minhas habilidades e essa coleção de artigos será uma aula tanto para o leitor quanto para o autor.

Bem primeiro vamos entender como a operação lógica xor(exclusive or) é usada em algoritmos criptográficos e porquê.

As operações lógicas são operações baseadas na lógica binária, ou é certo ou é errado.

O verdadeiro é representado pelo número 1 e o que é falso pelo número 0.

Na programação isso é comum.

if(szTexto == "ola" || szTexto == "Ola")

{

Bloco de comandos

}

A operação acima é uma operação or("ou" em português).

se a variável szTexto for igual a "ola" ou "Ola" então o que a operação lógica or faz é retornar verdadeiro(1) se uma das duas condições avaliadas ou ambos forem verdadeiras.

A exclusive or é quase a mesma coisa com o diferencial de que ela só retorna verdadeiro se um

dos dois valores for verdadeiro, e se ambos forem verdadeiros, ele retorna falso.

Vamos dar uma olhada na table dos possíveis valores e resultados:

A B Resultado

0 0 0

0 1 1

1 0 1

1 1 0

Quando ambos são falsos, o resultado da operação é falso, quando ambos são verdadeiro, resultado falso também.. ou seja, operandos iguais resultado falso.

É interessante notar que:

x = a xor b

a = x xor b

b = x xor a

Vejamos a veracidade dessa informação:

a = 101

b = 100

101 xor 100 = 001

Para fazer a conta simplesmente coloque um valor abaixo do outro:

1 0 1

1 0 0

____

0 0 1

Logo, x = 1;

Bem, vamos achar A só sabendo o valor de b...

B(100) xor X(1) = A(101)

Vamos descobrir B apartir de A agora...

A(101) xor x(001) = B(100)

O interessante é perceber que, o resultado de uma operação XOR entre dois valores, pode sempre ser usado para descobrir um valor.

Ou seja, se tivermos uma string e usarmos uma operação xor nela com um determinado valor, o resultado será uma string totalmente diferente, mas usando o tal valor usado no xor e essa string totalmente diferente, o resultado da operação será aquela string do começo.

Defato, o valor usado na operação xor com a string comum pode ser usado como chave para descobrir essa string após ser encriptada.

Vamos ver um exemplo disso em C...

#include <stdio.h>

int main()
{
char szStr[] = "sergio";
int iKey = 0x9;

printf("String: %s\n", szStr);

for(int iNum = 0; szStr[iNum]; ++iNum)
szStr[iNum] = szStr[iNum] ^ iKey;

printf("String encriptada: %s\n", szStr);

for(int iNum = 0; szStr[iNum]; ++iNum)
szStr[iNum] = szStr[iNum] ^ iKey;

printf("String desencriptada: %s\n", szStr);

return 0;
}

Ou seja, nós encriptamos uma string usando a operação lógica xor e uma chave(iKey) e depois à usamos para desencriptar a string.

Algoritmos de escrutínio costumam usar a mesma operação lógica, a diferença é que eles "jogam a chave fora" para que ninguem consiga descobrir a senha antiga... é claro que de uma forma mais complicada que conheceremos com o tempo aqui no blog. =]

ShellCoding parte 2 - asm básico > 2.1 sistemas numéricos

2008-10-16T08:50:00.001-07:00

Não tem, ou melhor, não deveria ter outra forma de introduzir alguém a uma linguagem sem passar por esse tema.
Sinta-se livre para passar por ele se já o conhecer.
Vou passar bem rápido por esse tema, ele é simples demais para perdermos tempo nele.
Um sistema numérico, é uma representação visual de uma contagem seqüencial.
Cada símbolo representa o número seguinte a ser contado, quando não há mais símbolos nós repetimos o segundo da seqüência ao lado esquerdo do número que estamos escrevendo e voltamos o número inicial ao seu primeiro símbolo.(famoso esquema do “vai um”)
A base que normalmente usamos para representar números é a decimal, logo nós temos:
1, 2, 3, 4, 5, 6, 7, 8, 9 e 10
Certo?
Errado!
0, 1, 2, 3, 4, 5, 6, 7, 8 e 9
É a seqüência certa...
Quando chegamos o no número nove (9) nós voltamos ao zero (0) e colocamos um ao seu lado para representar que já ultrapassamos da nossa seqüência uma vez e assim em diante.
Isso é fácil, mas é a base para qualquer base numérica, como a binária.
A base binária só tem dois números, o zero e o um e subseqüentemente segue a mesma lógica que a decimal para representar os mesmos números...
Vamos ver algumas representações em binário
Binário | Decimal
0            | 0
1             | 1
10          | 2
11        | 3
100        | 4
101         | 5
110         | 6
111         | 7
1000     | 8
1001      | 9

1010 | 10

Como podemos ver, cada vez que passamos do número de símbolos que temos, aumentamos um número a esquerda tanto na base decimal quanto na binária.
Parece bobeira de tão fácil, e é. Lolz
Geralmente nós temos que trocar de uma base para outra... Para trocar da base decimal para a binária e vice-versa eu uso uma tabela comum para técnicos e engenheiros eletrônicos, mas pouco comum no mundo da informática.
Ela é lógica e bem simples.
Vou fazer um exemplo da conversão do número 9 para binário utilizando ela.

16 | 8 | 4 | 2 | 1 <- cabeçalho

0 | 1 | 0 | 0 | 1

Essa tabela é composta por um cabeçalho, esse cabeçalho define colunas baseando-se em potencias de dois:

2 ^ 0 (^ significa “elevado a”) = 1

2 ^ 1 = 2

2 ^ 2 = 4

2 ^ 3 = 8

Esse cabeçalho pode ter quantos números você desejar.

Depois o que fazemos é pegar o número do cabeçalho que mais se aproxima do número que queremos transformar pra binário( 9 ), no nosso caso pegamos o oito. Depois nós pegamos um número que possamos somar com o oito para se tornar nove.( o um/1) Nas colunas dos números que nós pegamos nós colocamos o número um (1), em todas as outras, zero.

Vamos transformar o número 512 em binário para treinarmos. (PS: essa tabela é ótima para fazer em concursos porque ela é rápida e prática, melhor do que dividir milhares de vezes por dois e pegar o resto)

512 | 256 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1

1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0

Isso mesmo! Como já achamos o 512 de primeira, o resto é tudo zero... Acreditem, da outra maneira vocês iriam gastar muito tempo dividindo por dois até o final de suas vidas. Lolz

E se o número fosse 511.. bem como temos um número antes de uma potencia de dois, é só marcar 1 em todas as colunas anteriores.. vejam:

512 | 256 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1

0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1

111111111 é a resposta... Se quiserem somar todos os números anteriores com a calculadora de seus computadores verão que eu estou certo. E para fazer o processo inverso?! Isso é, transformar um número binário em decimal? Usamos nossa tabela novamente. Digamos que queiramos converter o número 111 para decimal...

8 | 4 | 2 | 1 <- cabeçalho

0 | 1 | 1 | 1

Agora é só somarmos os números que estão acima de cada 1 binário...

4+2 = 6

6 + 1 = 7

E pronto.

Nós também temos a base hexadecimal, que tem a seguinte seqüência simbólica: 0 1 2 3 4 5 6 7 8 9 A B C D E F Com ‘A’ representando o ‘10’, ‘B’ o ‘11’, ‘C’ o ‘12’ e assim por diante... Converter binário para hexadecimal e vice-versa é muito simples.

O maior número individual hexadecimal é igual ao maior número contido em um nibble(4 casas binárias/ 1 1 1 1) Então, cada número hexadecimal, nós convertemos para um nibble.. por exemplo “FF”(255) O primeiro F é o mesmo que 15 em decimal e corresponde ao nibble 1 1 1 1 e o segundo outra sequencia de quatro 1’s.

Logo, 1 1 1 1 1 1 1 1.

Só mais uma para termos um melhor idéia da operação..

O número A1 para binário vira

A 1

1010 0001

Eu normalmente faço a transformação de hexadecimal para decimal usando o deslocamento extra para não ter que ficar multiplicando fatores de 16.

Por exemplo o FF.

F = 15

E um dos F’s está uma casa a frente do primeiro.

150 > uma casa decimal acescentada + 15 = 165

O deslocamento é 90(15 * 6).
Logo, 90 + 165 = 255

Eu gosto dessa maneira porque me permite fazer de cabeça.. no entanto meus amigos acham ela de uma dificuldade absurda, talvez porque eu tenha criado ela de cabeça a um bom tempo atrás e acaba ficando mais fácil pra mim que visualizei a lógica por trás da conta do que para quem não visualizou a mesma. \=

Então não vou me ater a ela tanto assim.Vamos a técnica mais popular.Cada casa hexadecimal corresponde a uma quantidade de vezes que nós passamos dos 16 símbolos.

Logo, em FF

Nós temos
F x 16^0
+
F x 16^1
O que dá 255.
O procedimento contrário(transformar números decimais em hexadecimais se dá através de divisões consecutivas do número por 16 até não podermos mais dividir o resultado.

Let’s see it.

255 / 16 = 15,9375
15 é igual a F.
Ai nós multiplicamos o resto
0,9375 x 16 = 15
15 é F também, logo ‘FF’.

Para quem não entendeu, é porque eu realmente estou correndo... Infelizmente nem sempre a minha explicação é o suficiente, então se sinta à vontade para procurar em outros lugares a explicação sobre essa mesma matéria, eu pessoalmente recomendo esse link>
http://www.numaboa.com.br/informatica/oiciliS/assembler/textos/binHexPort.php

Clique aqui para ler a continuação

ShellCoding parte 1 - introdução

2008-10-16T08:46:00.000-07:00

Shell coding é uma arte a parte, algumas vezes, uma vulnerabilidade não é "exploitada" por que simplesmente o atacante não fez um shellcode pequeno o suficiente.
Achar vulnerabilidades é outra arte também... Saber juntar essas duas formas de arte para um objetivo principal pode e pode não ser uma tarefa difícil, mas tende a ser complexa muitas vezes.

Inicialmente, hackers e crackers viviam em mundos separados... A antítese de usuários comuns...
Hackers, historicamente vieram de sistemas de código aberto aonde as vulnerabilidades eram encontradas no código fonte liberado, não lidavam com dificuldades técnicas como unpacking e etc, no entanto conheciam a linguagem C muito bem.
Crackers vieram de um sistema de código fechado em especial(o windows) e costumeiramente tinham que "quebrar" o código de um software para conseguirem alcançar certos objetivos, que algumas vezes eram os mesmos que os dos hackers e outras vezes não eram.(como uso ilimitado de programas pagos)

De fato, a sabedoria popular é mais considerada do que a individual.
Digo isso porque a um tempo atrás a linguagem object pascal só poderia ser chamada assim. Como a maioria dos programadores novatos assimilavam o nome da linguagem com o do compilador(delphi), o nome da linguagem basicamente hoje em dia pode ser ambos.
Outro exemplo é a nossa língua em que palavras perdem acentos ou ganham de acordo com a forma que o povo mais escreve e fala.

Muitos hoje enxergam os cavaleiros como homens cheios de honra, moral e ética quando na realidade, os cavaleiros na época das cruzadas só sabiam matar e estuprar mulheres inocentes.
Assim é com hackers, na verdade a meu ver, o conceito só tem a ver com o conhecimento que você tem de hardwares e softwares... (vide o porquê do primeiro grupo de hackers terem se chamado assim)

No entanto como a sabedoria popular é a que tem a "última palavra", então hackers são seres angelicais, cheios de ética e com uma perfeita pronúncia da nossa língua nativa.

Crackers sempre foram e serão vistos como criaturas malvadas e quase sempre são confundidos com meros defacers com más intenções, principalmente em fóruns sensacionalistas.

Não que seja uma completa mentira, mas muitas vezes, um exagero.(poucos crackers praticam deface)

clique aqui para ler a continuação