Apostila De Assembly

[slipknot]

ola to querendo aprender assembly....=]

alguém sabe ai um site onde tem uma apostila?

abraços..

[xcel3nt]

Manual basico de Assembly

Manual basico de Assembly

26.10.01

- Write To Execute -

http://www.write2execute.cjb.net/

Desenvolvido por Gustavo Chagas a.k.a Rofeti

hophet@yahoo.com.br

Este e outros txts podem ser obtidos em:

http://www.write2execute.cjb.net/

http://www.bthzine.cjb.net/

Tanks Unsekurity Scene

http://www.unsekurity.com.br/

#####################################

##### Manual basico de Assembly #####

####### em Linux/i386 - AT&T ########

#####################################

* Indice

$0x1 - Introducao.

$0x2 - Introducao ao Assembly.

$0x3 - Modelo de Memoria.

$0x4 - O Stack.

$0x5 - Registradores.

$0x6 - Instrucoes.

$0x7 - Secoes.

$0x8 - System Calls.

$0x9 - Exemplos.

$0xa - Links.

$0xb - Terminando.

------------------

$0x1 - Introducao |

------------------

Ae irmaos, estive um tempo sumido, tive uns problemas com a minha

linha telefonica:/, mas já esta tudo resolvido, e a luta continua

:). Trago mais uma vez a voces minhas humildes palavras, com o

intuito de mostrarlhes um pouco mais sobre esta facinante linguagem

que é o Assembly. O mundo hoje esta vivendo um grande rebulico,

nacoes inteiras preocupadas com a sua seguranca, os especialistas

dizem que mesmo as mais drasticas medidas de seguranca não vao

resolver os problemas e que nada esta seguro hoje em dia. Serah o

fim do mundo?? hehehe talvez:). Nos resta esperar com uma certeza

no coracao, de que Deus irah voltar e se voce não estiver preparado,

não irah subir com ele:). Voltando ao assunto, este tutorial esta

direcionado a Newbies fucadores que querem entender um poukinho mais

do Assembly em linux/x86, vamos direcionar os nossos esforcos na

sinteze AT&T, se voce estiver interecado em ASM na sinteze INTEL,

procure algo nos links no final deste txt. só pra esclerecer

assembly é a linguagem e Assembler é o compilador ASM.

Quero dizer ao pessoal que o "w2x" estah vivendo um novo momento,

que é a procura de melhorar mais, e que estao vindo por ae gran_

des coisas realizadas pelo w2x, partindo por boms materiais como

este.

------------------------------

$0x2 - Introducao ao Assembly |

------------------------------

é, usaremos em todo o txt a sinteze AT&T, todos os exemplos são

para linux/x86, usaremos o "as" para criarmos o object file e o

linker "ld" para linkarmos o object file assim criando o executavel

Com o ASM no linux, trabalharemos com 32bit's em "Protect Mode",

Modelo de Memoria Flat, e com binarios ELF. Um programa Assembly é

dividido em secoes depois de compilado e antes tambem, depois de

compilado ele tem 3 secoes, a ".text" para o codigo(Read-Only), a

".data" para os dados(Read-Write) e a ".bss" para inicializacao de

dados(Read-Write), vou falar mais neles nas proximas secoes.

Como muitos já sabem com o Assembly se tem um poder total do sistema,

podendo se manipular desde registradores do processador ate a

memoria. Asm possibilita a criacao de programas bem menores e mais

rapidos que os feitos em outras linguagens, pois são feitos usando-

se diretamente a memoria e os system calls, por isso um controle

total do sistema.

Assembly permite que voce desenvolva suas proprias rotinas, usando

diretamente a memoria e chamadas de sistema, o que te possibilita

um poder muito grande.

* Alguma informacoes uteis

--------------------------

Sinteze AT&T:

-------------

Na sinteze AT&T o "origem" vem 1o que o "destino", um exemplo disso

seria "addl origem,destino".

Outro ponto importante é que os registradores recebem o sinal de

porcentagem "%", assim os registradores no AT&T são: %eax, %ebx,

%ecx, %edx, %esi, %edi, %esp, %ebp...

Os operandos recebem o sinal "$", assim "addl $3, %eax" que adiciona

3 ao %eax, se o "$" for omitido, ele serah tratado como um endereco

de memoria. Assim, "addl 3, %eax", o 3 serah tratado como um endereco

de memoria, adicionando o endereco ao %eax e "addl $3, %eax" serah

tratado como um openrando 3, ou variavel.

O "e" antes dos registradores indica que ele é "extendido"(32bits).

ex.: %ecx.

Unidades de medida:

-------------------

Eu aconselho ao pessoal interecado, a ler uma materia na edicao 00

da zine bth, sobre "conversao numerica" importante p/ um entendimento

maior deste txt, voce pode pega-la em "http://www.bthzine.cjb.net".

só para esclerecimento rapido:

1 bit = 0 ou 1

1 byte = 8 bits

1 kbyte = 1024 bytes

1 mbyte = 1024 kbytes

1 gbyte = 1024 mbytes

1 tbyte = 1024 gbytes

1 Nibble = 4 bits, valor maximo de 15.

1 Word = 16 bits ou 2 bytes, é o tamanho dos registradores 80x86.

1 DWord = 32 bits ou 4 bytes, é o tamanho dos registradores

linux/i386.

Compilando codigos ASM:

-----------------------

Para compilarmos programas Assembly usaremos "as" e "ld" como disse

um pouco antes... basicamente seria:

Criaremos o Object File...

$ as -o codigo.o codigo.s

E linkaremos...

$ ld -o codigo codigo.o

Pronto temos o nosso executavel final...

$ ./codigo

Mas vamos um pouco alem para criarmos um programa ainda menor,

do que temos.

Copie e compile este pequeno codigo para que possamos fazer os

nossos testes de compilacao...

<++> asm/big.s

#

# Programa teste de compilacao do txt de Assembly

#

.section .data

OI: .string "OI!!!\n"

TAM: .long . - OI

.section .text

.globl _start

_start:

movl $0x4, %eax

movl $0x1, %ebx

movl $OI, %ecx

movl TAM, %edx

int $0x80

movl $0x1, %eax

movl $0x0, %ebx

int $0x80

# eof

<-->

Compilado, vamos ver o seu tamanho...

$ wc -c big

754 big

Vemos que ele tem 754 bytes, vamos tentar diminuir este tamanho,

ainda mais. Veja:

$ as -o big.o -S0

$ ld -s -O0 -o big big.o

Com a opcao "-s" nos tiramos as informacoes dos simbolos do binario

final com isso ele diminui bastante o seu tamanho.

$ wc -c big

404 big

Vemos que agora ele tem 404 bytes.

Uma ferramenta muito boa para mais informacoes sobre o binario

e ate um entendimento maior de como um progrma é dividido é o

"objdump" que mostra boas informacoes... Tente aih um:

$ objdump -x big

Para mais informacoes "man objdump".

Comentarios em Assembly:

------------------------

Os comentarios em ASM variam de tipo, de acordo que muda o

tipo de programacao em ASM, o comentario usado por nos neste

txt, usando o assembler as e o ld no AT&T é o sinal de cer_

quinha(#), assim "# isto é um comentario" pra nos é o nosso

comentario. Pro pessoal da sinteze Intel, seria usado o sinal

ponto e virgula, assim "; isto é um comentario" pra eles é

um comentario, mas nos no atentaremos para o cerquinha "#".

Ex.:

#

# Muito obrigado por ler este COMENTARIO :D

# !! w2x - vive em nossos coracoes - w2x !!

#

Os perenteses:

--------------

Os parenteses "()" são os "Operandos de Memoria" do Assembly

na sinteze AT&T, a base do registrador é envoldida em "("

e ")". Eles são responsaveis por facilitar operacoes

envolvendo registradores e enderecos de memoria. Ex.:

leal 4(%eax), %ebx

movl (%eax, %ebx, $0x4), %esp

movl (%ebx), %eax

-------------------------

$0x3 - Modelo de Memoria |

-------------------------

Como já foi dito antes um linux/i386 possui o modelo flat de

32bit's, onde os registradores, vao de 8 a 32bit's. Um programa

pode ser dividido em tres partes ou secoes como preferir. são

elas:

.data (Stack) => para seus dados, variaveis, etc. Read-Write.

.bss (Heap) => para dados indefinidos, inicializacao de dados.

Read-Write.

.text => para seu codigo. Read-Only.

Um programa ASM tem que ter no minimo a secao ".text". Um programa

em "C" possue varias secoes alem dessas.

Segmentos de Memoria: é todo o local na memoria alocada pelo

programa.

offset(deslocamento): é um local(parte) do espaco na memoria

alocada pelo programa.

Ex.:

1 2 3 4 -> offset's

-------------

|A-|B-|C-|D-| -> 100

-------------

I___________I

I

Segmento

Por exemplo o "A" se encontra no segmento "100" e no offset "1",

e o "D" se encontra no segmento "100" e no offset "4". Mas em

vez de numeros decimais como acima, são usados numeros hexa_

decimais ou ate binarios.

A memoria de todos os PC's é dividida em "segmentos", cada

segmento possui 64kbytes, e eles são separados por 16bits, ou

seja, o 1o segmento é distante 16bits do 2o segmento. Aih

entra o offset, se quizesemos localizar o "vigesimo(20)" byte

do segmento "0", teriamos "0:20", ou seja, segmento 0 offset 20,

lembrando que seria tudo em hexadecimal (Aconselho a leitura da

materia indicada na secao "Unidades de Medida"), mais ou menos

assim "0x0:0x14", só que seriam enderecos de memoria mesmo,

pelo menos no segmento.

---------------

$0x4 - O Stack |

---------------

O Stack funciona de acordo com o sistema LIFO(Ultimo a entrar,

primeiro a sair). Regiao responsavel por receber dados e passa_

los as funcoes, ou a quem os requisitar. Conhecido como Stack ou

Pilha, pelo fato de funcionar realmente como uma, ou seja, o ulti_

mo a entrar na "pilha" vai ser o primeiro a sair da "pilha". Usa_

mos o "push" para colocarmos dados no Stack e o "pop" para tirarmos

dados do Stack, os mesmos serao descritos mais abaixo. Repare este

exemplo:

push $0x2e # .

push $0x54 # T

push $0x45 # E

push $0x48 # H

push $0x50 # P

push $0x4f # O

push $0x48 # H Stack = HOPHET

pop %esp # clear stack. Stack = 0

Se usasemos a syscall write para escrever na tela o Stack Pointer

teriamos 1o o "H" depois o "O" e assim por diante ate completar o

"HOPHET". A pilha ou Stack, serve para se armazenar dados que

poderao ser recuperados sem