• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

Felix_Poison

Basico Sobre Assembly AT&T - Felix_Poison

4 mensagens neste tópico

Lembrando que esse texto é BETA, e eu nao terminei ele, mas como sou ansioso, vim posta-lo aqui. peço que esperem e aguardem a versao original e final.

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

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

## 04 - UM POUCO SOBRE O STACK (PILHA) ##

A região denominada Stack ou pilha (mesma coisa), é responsavel por

salvar o endereço de subrotinas, passar argumentos (dados) para funçoes,

armazenar variaveis locais e etc. Como o propio nome sugere, o stack (pilha)

funciona como uma pilha, onde voce vai pondo dados lá.

logo, o esquema seria o mesmo de uma pilha de livros, por exemplo.

o ultimo livro que voce por nessa pilha, será o primeiro a sair, o primeiro

a ser pego, correto?. fugindo um pouco dos termos tecnicos,

imagine a stack como um clube de festa (meu deus..), e as pessoas

que entraram nessa festa serão os dados.. caso, o cara que chegar por ultimo

na festa quiser sair, ele terá que ser o primeiro a sair..

esse esquema é chamado de LIFO - Last in, first out (ultimo a entrar,

primeiro a sair). dois comandos em asm sao usados com relaçao a stack :

PUSH (empurra) e POP (retira) dados, veremos isso melhor no capitulo

sobre intrunçoes em assembly :thumbsup:

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

## 05 - BASICO SOBRE ASSEMBLY ##

isso aqui será o basico do basico, cara, logo é recomendavel que voce

procure alguma apostila sobre asm, ou espere as minhas =)

oque seria falado aqui é o basico para podermos entender e escrever

shellcodes. logo, se voce quiser se aprofundar em shellcodes, terá que

se aprofundar em asm.

vamos ver sobre alguns registradores e algumas instrunçoes que

usaremos no decorrer do texto.

**************************

** 05.1 - Registradores **

Registradores sao blocos de memoria do processador que sao usadas

para recebere guardar variaveis.

antes dos processadores i386, os registers eram de 16 bits apenas

já nos modelos i386 pra cima, eles possuem 32 bits.

vejamos alguns registers de uso geral, no qual podemos armazenar qualquer valor.

EAX = Extended Acumullator (Registrador aculador extendido)

EBX = Extended Base (Registrador de base extendido)

ECX = Extended Couter (registrador contador extendido)

EDX = Extended Data (registrador de dados extendido)

como eu disse, nos processadores atuais, os registers sao de 32 bits,

que é o caso desse ae de cima. para isso, foi adicionado o 'E'

de extendido no começo do nome original dos registers.

os registers de 16 bits tinham seus nomes apenas : ax,bx,cx,dx, mas como

eles sao de 32 bits agora, ganhanram o "E".

cada register desse possui 32 bits. eles possuem duas partes de 16 bits cada

esses 16 bits são os 16 bits 'altos' e os 16 bits 'baixos'.

os 16 bits mais altos possuem tambem, duas partes de 8 bits cada:

a parte alta (high) e a parte baixa (low). para representar esse tipo de

register, usamos o seu nome seguido de H para alto ou do L de low para baixo.

ficando assim : al e ah, bl e bh, cl e ch, dl e dh.

vamos ver uma imagem pra ficar melhor de entender, vamos usar o register

EAX como exemplo, mas todos os outros citados anteriormente seguem

o mesmo modelo :

                                         

                                        ---------AH (8 bits alto)

                                        |

                                        |

          ------------ AX (16 bits altos)

          |                            |

          |                            |

EAX(32 BITS)                            ----------AL (8 bits baixo)

          |

          |

          ------------- 16 bits baixos

acaso alterarmos o valor de al, por exemplo, tambem seria mudado o valor

de ax e eax. exemplo: se movessmos o valor 0x00000000 para EBX, ficaria:

EBX = 0x00000000

BX(parte alta de ebx) = 0x0000

BH e BL (parte alta e baixa de BX) = 0x00

e vice-versa, se movessemos o valor 0x00 para bl, bx teria o valor de

0x0000 e ebx seria 0x00000000. no caso, o mesmo valor :)

há varios outros tipos de registers alem desses de uso geral,

mas pararei por aqui nesse texto.

como disse, isso é o basico para podermos continuar com o texto.

vamos lá..

***********************************

** 05.2 - Istrunçoes Em Assembly **

Bem, tratarei de algumas intrunçoes apenas, que é as que usaremos aqui.

só pra quem ainda nao sabe, intrunçoes sao os comandos em asm.

antes, vamos ver algumas coisinhas para nao restar duvidas:

para indicar um registrador como tal, deve-se usar o ' % ' (por cento)

antes do nome, exemplo: %EAX, %ah, %ebp..

em caso de voce indicar um endereço de memoria, voce só precissa por

o valor do endereço, mas se for um valor normal, voce deve por o ' $ '

antes, exemplo: para mover o endereço 0x0047abbc para o register %ah,

basta por o esse valor mesmo, sem caracter adicional.

agora, se voce quer mover um valor normal, exemplo: 0xcd para %dh, deve-se

por o '$', ficando assim: $0xcd. Isso é regra!

so lembrando que essa sintaxe usada é a AT&T (Unix). logo, é diferente da

sintaxe INTEL (DOS).

@--> Intrunçoes De Transferencia (mov,lea,push,pop)

sao instunçoes usadas para transferir dados, logicamente.

vamos ver apenas alguns dos tais:

MOV -> usada para mover valores de um lugar para outro na memoria.

sintaxe: MOV origem, destino. exemplo: MOV $0xc1, %EAX

oque esse exemplo faz é mover o valor 0xc1 para %eax, que agora vale 0xc1.

outro exemplo:

MOV $0x0cf84c00, %ECX

MOV $0x42, (%ECX)

nesse exemplo, o primeiro comando move o valor $0x0cf84c00 para %ECX

e o segundo move o valor $0x42 para o endereço que está armazenado em %ECX

para isso, usamos os parenteses, se nao, o valor 0x42 seria movido para ECX

fazendo com que ele perdesse o seu valor original.

LEA -> Parecido com o mov, só que ele é capaz de efetuar calculos

mais rapidamente antes da transferencia: sintaxe: LEA origem, destino

exemplo: LEA 4 (%EBX), %EAX

isso faz o seguinte: adiciona o valor 4 para EBX e logo depois 'enfia'

tudo para EAX, sem o LEA, nosso codigo ficaria assim :

add $0x4, %EBX

mov %EBX, %EAX

viu? o lea economiza tempo :)

PUSH -> Empurra os dados sobre a pilha (stack). Sintaxe : PUSH valor.

exemplo: PUSH $0x43. Nesse exemplo, a instrução PUSH, empurra

o valor $0x43 para o stack.

POP -> ao contrario de push, pop retira os dados do stack

lembrando que o esquema do stack é o LIFO(ultimo a entrar, primeiro a sair)

sendo assim, o pop irá retirar primeiro o ultimo dado inserido no stack

MOV %EAX, %EDX

PUSH %EDX

PUSH $0x0

POP $0x0

@--> Istrunçoes Logicas E Aritmeticas

intrunçoes aritmeticas sao usadas para realizaçao de calculos

(operaçoes aritmeticas) nos operadores. sao eles:

ADD -> adiciona dois operadores. ex:

mov $0x05, %al

add $0x01, %al

Ae, primeiro movemos o valor para %al e depois adicionamos 0x01 para ele

que agora vale 0x06 (0x05 + 0x01)

SUB -> usado para subtração de operadores e tambem pode ser usado para alocar

espaço no stack para receber dados. ex:

mov $xb, %al

sub 0x2, %al

Ae, primeiro fizemos com que al valesse 11 (b[hexa]), depois subtrai

2 de al, que agora vale 0x9 (0xb - 0x2 ). EX2 :

sub $0x05, %esp. esse ultimo exemplo, reserva 5 bytes no stack.

INC -> incrementa um operando. ex:

mov $0x04, %ah

inc %ah

ae, %ah agora valerá 5, que antes era 4.

DEC -> inverso de INC, dec decrementa um determinado operando. ex:

mov $0xa, %ah

dec %ah

ae, %ah agora valerá 9.

existem outras istrunçoes aritmeticas, mas por hora vamos ver somente essas.

agora vamos ver as istrunçoes logicas:

As istrunçoes logicas, sao usadas para operaçoes logicas, vamos ver alguns:

AND -> como o propio nome diz, ele é o "É" das operaçoes logicas.

ex: and $0x0f, %cl

OR -> é o "OU" logico. tipo: "guria, voce quer ficar comigo "OR" com ele?

ex: or $0x0f, %bx

NOT -> é o 'NÃO' logico. pode ser usado para inverter bits de um byte.

ex: not %eax

XOR -> funciona da mesma forma que OR, mas ele é 'vip', só é usado

se uma variavel tiver o resultado esperado. ex: XOR %ecx

@--> Instruçoes De Comparaçao E Repetiçao

logicamente, as instruçoes de comparaçao sao usadas para comparar algo. veja:

CMP -> compara dados sendo usados. ex: CMP $0x5, %eax

TEST -> Usada em comparaçoes logicas, fazendo uma chegagem

no register, para ver se tal esta tudo certo; ex: TEST %EDX, %EDX

agora de repetiçao:

LOOP -> verefica se o register %ECX é diferente de zero. se for,

ele decrementa '1' (%ecx - 1) e salta para o endereço passado como parametro

se for zero, ele continua normal..

@--> Instruçoes De Desvio De Programa (Salto)

sao usados para alterar a execucção normal de um programa. sao eles:

JMP -> Abreviação de jump (salto,pular), essa instruçao faz saltos

incondicionais para um determinado endereço de memoria. ex: JMP 0xc

é importante lembrar que JMP nao possui nennhum tipo de retorno, logo,

se voce saltar para algum endereço de memoria, nao tem forma simples

de voce voltar a execucção do programa de onde parou.

CALL -> Usada para chamar uma subrotina e para saltos como JMP,

só que com CALL é possivel voltarmos a execução normal do prog.

ex: CALL 0x081400cd . no caso, o endereço da proxima execução apos o salto

é salvo no topo do stack.

To Be Continued...

Author: Felix_Poison

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Estava esperando ver se ninguem ia ler, ou comentar algo, ou sei lá :P

independente disso, a versão final já está sendo produzida. como eu disse, eu quero algo revolucionario, quero ver gringo morrendo pra tentar entender o nosso amado português e valorizar mais nossos paises, entao, nao vai ser coisa pouca, ae demora um pouco mesmo :)

fique atento :)

abraços

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora