SlideShare una empresa de Scribd logo
1 de 34
Descargar para leer sin conexión
Oficina
Assembly para Linux
      Por Luiz Vieira
      @HackProofing
Quem sou eu?
Cool 3   assembly para linux
Organização do Sistema
                  CPU
Registradores
                 Execução       Controle
    Flags




        I/O     Barramentos   Memória
Registradores
• Uso geral:
  – EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP


• Segmento:
  – CS, DS, ES, SS, FS, GS


• Instrução:
  – EIP


• Controle:
  – CR0, CR1, CR2, CR3, CR4
Registradores
• EAX = Extended Acumullator (registrador acumulador extendido)
• EBX = Extended Base (registrador de base extendido)
• ECX = Extended Couter (registrador contador extendido)
• EDX = Extended Data (registrador de dados extendido)
• ESI = Extended Source Index (registrador de índice de origem
  extendido)
• EDI = Extended Destination Index (registrador de índice de destino
  extendido)

• Em adição aos registradores de uso geral, temos os registradores
  especiais, que são:
    –   EBP = Extended Base Pointer (Ponteiro de Base)
    –   ESP = Extended Stack Pointer (Ponteiro de Stack/Pilha)
    –   EIP = Extended Instruction Pointer (Ponteiro de Instrução)
    –   EFLAGS
Registradores
• Uma coisa que precisamos ter sempre em mente, é que
  tanto como o EIP quanto o EFLAGS, só poderão ser
  acessados através de instruções especiais e bem
  específicas, diferente dos demais registradores.


• O EBP sempre aponta para a base da pilha, e também é
  utilizado para acessar essa mesma pilha, apesar de
  também poder ser utilizado como um registrador comum
  (de uso geral). Já o ESP, aponta para a posição atual da
  stack (pilha) e é o 'offset' do SS (Stack Segment).
Organização de um registrador
        para uso geral
                                    EAX

31                                                                         0

                                                           AX

31                             16         15                               0

                                               AH                   AL
                                          15           8        7          0

 •EAX armazenaria, por exemplo, um valor fictício de 0x00000000.
 •AX, que é a parte alta de EAX, armazenaria 0x0000.
 •AH, é a parte alta de AX, enquanto AL é a parte baixa de AX (ambos são
 de arquitetura 8bits), e armazenam apenas 0x00 cada um.
AT&T x Intel
• Intel =




• AT&T =
AT&T x Intel
• Na sintaxe Intel, uma instrução comum ficaria assim:
    – instrução destino, origem

• Em AT&T é:
    – instrução origem, destino


• Uma questão importante de se lembrar, é que na sintaxe AT&T,
  todos os registradores devem ser prefixados pelo símbolo %,
  enquanto que o valores literais, pelo símbolo $. Portanto, 100 é
  diferente de $100, onde o primeiro é um endereço de memória, e o
  segundo é um valor numeral.

• Outro símbolo importante, é o '$0x' utilizado para referenciar
  hexadecimais.
Primeiro programa
#OBJETIVO: Programa simples que executa um exit e retorna um código de status para o kernel Linux
#ENTRADA: nenhuma
#OUTPUT: retorna um status código de status, que pode ser visto executando no terminal o comando:
# echo $?
# após a execução do programa
#VARIÁVEIS:
# %eax armazena o número da syscall
# %ebx armazena o status retornado


.section .data
.section .text
.globl _start
_start:
movl $1, %eax           # esta é a syscall do kernel Linux para sair de um programa
movl $0, %ebx           # este é o status que retornaremos para o SO.
                        # altere esse valor, e verá coisas diferentes ao executar
                        # echo $?
int $0x80               # isso chama o kernel para executar a syscall 1
Execução
• Salve este código como 'exemplo1.s', compile e
  linkedite-o:

  # as exemplo1.s -o exemplo1.o
  # ld exemplo1.o -o exemplo1

  Após este processo, para executar nosso
  primeiro programa, basta digitar no terminal:

  # ./exemplo1
Explicação
•   .section .data = cria a seção "data", onde listamos quaisquer containers de memória.

•   .section .text = seção onde inserimos as instruções a serem executadas.

•   .globl _start = '.globl' é uma instrução que diz que o símbolo '_start' não deve ser descartado
    após a compilação e linkedição do código.

•   _start: = é onde definimos o valor do label '_start', que terá vinculado à si, o conjunto de
    instruções que seguem logo abaixo.

•   movl $1, %eax = aqui temos a instrução 'movl', seguido de dois operadores. Nesse caso,
    inserimos o valor 1 no registrador EAX. Esse número é o valor de uma syscall específica (exit -
    para conhecer os valores das demais 'syscall', execute o comando "cat /usr/include/asm-
    i386/unistd.h" no terminal Linux*).

•   movl $0, %ebx = inserimos o valor "0" no registrador EBX. Isso é o que dirá para o kernel que
    está tudo ok para o 'exit' ser executado.

•   int $0x80 = 'int' é o mesmo que 'interrupt'. Uma interrupção corta o fluxo de funcionamento de um
    programa e passa o comando para o Linux, o que em nosso caso, fará com que o kernel execute
    a 'syscall 1 '(exit). E o valor '$0x80' é o número de interrupção utilizado para que essa passagem
    de controle para o Linux aconteça.


              * No Ubuntu, o arquivo está em: /usr/include/asm/unistd.h
Segundo programa
.data

HelloWorldString:
    .ascii "Hello Worldn"

.text

.globl _start

_start:
    movl $4, %eax                            # syscall write()*
    movl $1, %ebx                            # parâmetro da syscall para definir STDOUT (fd)
    movl $HelloWorldString, %ecx             # local da mem. onde se encontra o container com a string (Buf)
    movl $12, %edx                           # tamanho da string (count)
    int $0x80

    movl $1, %eax                            # syscall exit()
    movl $0, %ebx
    int $0x80

                 * Syscall write() = ssize_t write(int fd, const void *Buf, size_t count);
Passagem de syscalls e
           argumentos
• De que maneira podemos passar os
  valores de syscall e seus argumentos?

  – EAX – número da system call
  – EBX – primeiro argumento
  – ECX – segundo argumento
  – EDX – terceiro argumento
  – ESI – quarto argumento
  – EDI – quinto argumento
Execução
• Salve este código como 'exemplo2.s', compile e
  linkedite-o:

  # as exemplo2.s -o exemplo2.o
  # ld exemplo2.o -o exemplo2

  Após este processo, para executar nosso
  primeiro programa, basta digitar no terminal:

  # ./exemplo2
Tipos de dados
• Espaço reservado em tempo de compilação (em .data):
   –   .byte = 1 byte
   –   .ascii = string
   –   .asciz = string terminada em null
   –   .int = integer de 32 bits
   –   .short = integer de 16 bits
   –   .float = número single com ponto flutuante
   –   .double = número double com ponto flutuante


• Espaço criado em tempo de execução (em .bss):
   – .comm = declara área comum da memória
   – .lcomm = declara área local comum da memória
Terceiro programa
.data
    HelloWorld:
           .ascii "Hello World!"
    ByteLocation:
           .byte 10
    Int32:
           .int 2
    Int16:
           .short 3
    Float:
           .float 10.23
    IntegerArray:
           .int 10,20,30,40,50

.bss
        .comm LargeBuffer, 10000
.text
        .globl _start
        _start:
                nop
                movl $1, %eax
                movl $0, %ebx
                int $0x80
Execução
• Salve este código como 'exemplo3.s', compile e
  linkedite-o:

  # as –gstabs exemplo3.s -o exemplo3.o
  # ld exemplo3.o -o exemplo3

  Após este processo, para executar nosso
  primeiro programa, basta digitar no terminal:

  # ./exemplo3
• # gdb ./exemplo3
Execução
•   (gdb) list
•   (gdb) break *_start+1
•   (gdb) run
•   (gdb) info variables
•   (gdb) help x
•   (gdb) x/12cb [endereço de HelloWorld]
•   (gdb) x/1db [endereço de ByteLocation]
•   (gdb) x/1dw [endereço de Int32]
•   (gdb) x/1dh [endereço de Int16]
•   (gdb) x/1fw [endereço de Float]
•   (gdb) x/5dw [endereço de IntegerArray]
•   (gdb) x/10db [endereço de LargeBuffer]
•   (gdb) x/100db [endereço de LargeBuffer]
MOVx
• É uma das instruções mais utilizadas em Assembly
• Sua utilização é basicamente a seguinte:
   – movx origem, destino

   – movl  movimenta valores de 32bits
      movl %eax,%ebx

   – movw  movimenta valores de 16bits
      movl %ax,%bx

   – movb  movimenta valores de 8bits
      movl %ah,%bh
Movendo dados
• Entre registradores:
  movl %eax, %ebx


• Entre registradores e memória:
     local:
           .int 10


     movl %eax, local
     movl local, %ebx
Movendo dados
• Valor direto no registrador:
     movl $10, %ebx

• Valor direto na memória:
     local:
          .byte 0

     movl $10, local
Movendo dados
• Em um endereço indexado da memória:
    IntegerArray:
          .int 10, 20, 30, 40, 50

• Para selecionar o 3º valor da integer (30)
  – BaseAddres(offset, index, size) =
  – IntegerArray(0, 2, 4)


     movl %eax, IntegerArray(0, 2, 4)
Quarto programa
.section .data
string: .string "Digite algo:n"
tam: .long . - string

.section .text

.globl _start

_start:

movl $4, %eax                 #    insere o valor 4, para a chamada da syscall write no EAX
movl $1, %ebx                 #    passa o parâmetro da syscall 4 para que algo seja exibido
leal string, %ecx             #    carrega o endereço de memória do ECX e exibe o conteúdo de string
movl tam, %edx                #    armazena o valor de tam no EDX
int $0x80

movl %esp, %ecx               #    Salva o Stack Pointer em %ecx
subl $10, %esp                #    Reserva 10 bytes para o usuario digitar no stack
movl $3, %eax                 #    insere o valor da syscall read (3) no EAX
movl $9, %edx                 #    Tamanho do que vai ser lido para EDX
int $0x80

movl %eax, %edx               # Move o que foi digitado para EDX.
movl $4, %eax                 # syscall write
movl $1, %ebx
int $0x80

movl $0x1, %eax
movl $0x0, %ebx
int $0x80
Execução
• Salve como 'leia.s'.
• Compile, linkedite e execute:

 # as leia.s -o leia.o
 # lf leia.o -o leia
 # ./leia
Quinto programa
.section .data
string1: .string "Criar um arquivo e inserir conteúdo n"
tam1: .long . - string1
string2: .string “Viva o Linuxn"
tam2: .long . - string2
arq: .string "/tmp/arquivo.txt"

.section .text

.globl _start
_start:

movl $4, %eax           # syscall write
movl $1, %ebx
leal string1, %ecx
movl tam1, %edx
int $0x80

movl $5, %eax           #   syscall open (5)
movl $arq, %ebx         #   arquivo que será aberto
movl $03101, %ecx       #   modo do arquivo
movl $0, %edx           #   Permissão 0
int $0x80
Quinto programa
movl %eax, %esi      # Move o retorno da funcao open para ESI

movl $4, %eax        #   syscall write, para efetuar a escrita no arquivo
movl %esi, %ebx      #   local de escrita, arquivo.txt
leal string2, %ecx   #   escrita do conteúdo de string2 para dentro do arquivo
movl tam2, %edx      #   O tamanho da variavel
int $0x80


movl $6, %eax        # syscall close (6)
movl %esi, %ebx      # Fecha o arquivo
int $0x80

movl $1, %eax
movl $0, %ebx
int $0x80
Execução
• Salve como ‘escreva.s'.
• Compile, linkedite e execute:

 # as escreva.s -o escreva.o
 # lf escreva.o -o escreva
 # ./escreva
Comparação – Sexto programa
.section .data

data_items: .long 3,67,34,222,45,75,54,34,44,33,22,11,66,0
.section .text
.globl _start

_start:
    movl $0, %edi                            # insere 0 no registrador índice
    movl data_items(,%edi,4), %eax           # carrega o primeiro byte de dados
    movl %eax, %ebx                          # como este é o primeiro item, %eax é o maior
    start_loop:
    cmpl $0, %eax                            # verifica se alcançamos o final
    je loop_exit
    incl %edi                                # carrega o próximo valor
    movl data_items(,%edi,4), %eax
    cmpl %ebx, %eax                          # compara valores
    jle start_loop                           # pula para o loop se o novo valor não for o maior
    movl %eax, %ebx                          # grava o valor como o maior
    jmp start_loop                           # pula para o início do loop
    loop_exit:
                                             # %ebx é o código de status para a syscall exit
                                             # e já possui o valor mais alto
    movl $1, %eax
    int $0x80
Execução
• Salve como ‘maximo.s'.
• Compile, linkedite e execute:

 # as maximo.s -o maximo.o
 # lf maximo.o -o maximo
 # ./maximo
 # echo $?
Condicionais
•   je
     – Pula (Jump) se os valores são iguais
•   jg
     – Pula se o segundo valor for maior que o primeiro
•   jge
     – Pula se o segundo valor for maior ou igual ao primeiro
•   jl
     – Pula se o segundo valor for menor que o primeiro
•   jle
     – Pula se o segundo valor for menor ou igual ao primeiro
•   jmp
     – Pula não importa o resultado da comparação (se houver uma). Esse Jump não
       precisa ser precedido por uma comparação


•   OBS: uma condicional normalmente é precedida por um cmpl (comparando
    dois valores):
                   cmpl $0, %eax
                   je loop_exit
Cool 3   assembly para linux
Contatos


         Luiz Vieira
http://hackproofing.blogspot.com
       http://www.oys.com.br
         luizwt@gmail.com
      luiz.vieira@oys.com.br
       luiz.vieira@owasp.org

Más contenido relacionado

La actualidad más candente

C. Bombardelli - Desassembler routine in text mode built in assembly language
C. Bombardelli - Desassembler routine in text mode built in assembly languageC. Bombardelli - Desassembler routine in text mode built in assembly language
C. Bombardelli - Desassembler routine in text mode built in assembly languageClovis Bombardelli
 
Iteraveis e geradores em Python
Iteraveis e geradores em PythonIteraveis e geradores em Python
Iteraveis e geradores em PythonLuciano Ramalho
 
Desenvolvendo Extensões PECL
Desenvolvendo Extensões PECLDesenvolvendo Extensões PECL
Desenvolvendo Extensões PECLW3P Projetos Web
 
Python para quem sabe Python (aula 2)
Python para quem sabe Python (aula 2)Python para quem sabe Python (aula 2)
Python para quem sabe Python (aula 2)Luciano Ramalho
 
Pipeline desdobramento escalonamento
Pipeline desdobramento escalonamentoPipeline desdobramento escalonamento
Pipeline desdobramento escalonamentoElaine Cecília Gatto
 
Vetores, Matrizes e Strings em C Parte 3
Vetores, Matrizes e Strings em C Parte 3Vetores, Matrizes e Strings em C Parte 3
Vetores, Matrizes e Strings em C Parte 3Elaine Cecília Gatto
 
Conceitos de ponteiros struct e buffers
Conceitos de ponteiros struct e buffersConceitos de ponteiros struct e buffers
Conceitos de ponteiros struct e buffersRodrigo Almeida
 
Python e django na prática
Python e django na práticaPython e django na prática
Python e django na práticaRafael Cassau
 
Arduino e Python: Do It Yourself
Arduino e Python: Do It YourselfArduino e Python: Do It Yourself
Arduino e Python: Do It YourselfBruno Nascimento
 
Python: Iteraveis, geradores etc
Python: Iteraveis, geradores etcPython: Iteraveis, geradores etc
Python: Iteraveis, geradores etcLuciano Ramalho
 
Linguagem C - Vetores, Matrizes e Funções
Linguagem C - Vetores, Matrizes e FunçõesLinguagem C - Vetores, Matrizes e Funções
Linguagem C - Vetores, Matrizes e FunçõesElaine Cecília Gatto
 
Estrutura de Dados - Alocação dinâmica de memória
Estrutura de Dados - Alocação dinâmica de memóriaEstrutura de Dados - Alocação dinâmica de memória
Estrutura de Dados - Alocação dinâmica de memóriaAdriano Teixeira de Souza
 
Biblioteca strings profª ms
Biblioteca strings profª msBiblioteca strings profª ms
Biblioteca strings profª msJoelsa Soares
 

La actualidad más candente (20)

Introducao Google GO
Introducao Google GOIntroducao Google GO
Introducao Google GO
 
C. Bombardelli - Desassembler routine in text mode built in assembly language
C. Bombardelli - Desassembler routine in text mode built in assembly languageC. Bombardelli - Desassembler routine in text mode built in assembly language
C. Bombardelli - Desassembler routine in text mode built in assembly language
 
Estrutura de Dados - Ponteiros
Estrutura de Dados - PonteirosEstrutura de Dados - Ponteiros
Estrutura de Dados - Ponteiros
 
Iteraveis e geradores em Python
Iteraveis e geradores em PythonIteraveis e geradores em Python
Iteraveis e geradores em Python
 
Python 04
Python 04Python 04
Python 04
 
Desenvolvendo Extensões PECL
Desenvolvendo Extensões PECLDesenvolvendo Extensões PECL
Desenvolvendo Extensões PECL
 
Python para quem sabe Python (aula 2)
Python para quem sabe Python (aula 2)Python para quem sabe Python (aula 2)
Python para quem sabe Python (aula 2)
 
Python 05
Python 05Python 05
Python 05
 
Pipeline desdobramento escalonamento
Pipeline desdobramento escalonamentoPipeline desdobramento escalonamento
Pipeline desdobramento escalonamento
 
Linguagem C - Strings
Linguagem C - StringsLinguagem C - Strings
Linguagem C - Strings
 
Vetores, Matrizes e Strings em C Parte 3
Vetores, Matrizes e Strings em C Parte 3Vetores, Matrizes e Strings em C Parte 3
Vetores, Matrizes e Strings em C Parte 3
 
Conceitos de ponteiros struct e buffers
Conceitos de ponteiros struct e buffersConceitos de ponteiros struct e buffers
Conceitos de ponteiros struct e buffers
 
Curso de Python e Django
Curso de Python e DjangoCurso de Python e Django
Curso de Python e Django
 
Python e django na prática
Python e django na práticaPython e django na prática
Python e django na prática
 
Arduino e Python: Do It Yourself
Arduino e Python: Do It YourselfArduino e Python: Do It Yourself
Arduino e Python: Do It Yourself
 
Python: Iteraveis, geradores etc
Python: Iteraveis, geradores etcPython: Iteraveis, geradores etc
Python: Iteraveis, geradores etc
 
Linguagem C - Vetores, Matrizes e Funções
Linguagem C - Vetores, Matrizes e FunçõesLinguagem C - Vetores, Matrizes e Funções
Linguagem C - Vetores, Matrizes e Funções
 
Estrutura de Dados - Alocação dinâmica de memória
Estrutura de Dados - Alocação dinâmica de memóriaEstrutura de Dados - Alocação dinâmica de memória
Estrutura de Dados - Alocação dinâmica de memória
 
Iteraveis e geradores
Iteraveis e geradoresIteraveis e geradores
Iteraveis e geradores
 
Biblioteca strings profª ms
Biblioteca strings profª msBiblioteca strings profª ms
Biblioteca strings profª ms
 

Similar a Cool 3 assembly para linux

Aula 7 conjunto de instrucoes
Aula 7   conjunto de instrucoesAula 7   conjunto de instrucoes
Aula 7 conjunto de instrucoesCratuscb
 
Lógica de programação pascal
Lógica de programação   pascalLógica de programação   pascal
Lógica de programação pascalJocelma Rios
 
Apostila para aprender sobre CPUs e tudo mais
Apostila para aprender sobre CPUs e tudo maisApostila para aprender sobre CPUs e tudo mais
Apostila para aprender sobre CPUs e tudo maisGilberto Mota
 
Programação básica de microcontroladores
Programação básica de microcontroladoresProgramação básica de microcontroladores
Programação básica de microcontroladoresDanilo Morais Pagano
 
Prova 2012 2_p4_gabarito
Prova 2012 2_p4_gabaritoProva 2012 2_p4_gabarito
Prova 2012 2_p4_gabaritoAmélia Moreira
 
Criando sua própria linguagem de programação
Criando sua própria linguagem de programaçãoCriando sua própria linguagem de programação
Criando sua própria linguagem de programaçãoronaldoferraz
 
Criando um sistema operacional básico
Criando um sistema operacional básicoCriando um sistema operacional básico
Criando um sistema operacional básicoVHC Informatica
 
O que mudou no Ruby 1.9
O que mudou no Ruby 1.9O que mudou no Ruby 1.9
O que mudou no Ruby 1.9Nando Vieira
 
Alocação dinâmica em C
Alocação dinâmica em CAlocação dinâmica em C
Alocação dinâmica em CBruno Oliveira
 
Aula c++ estruturas de dados
Aula c++   estruturas de dadosAula c++   estruturas de dados
Aula c++ estruturas de dadosJean Martina
 
Processador CISC RISC SET de instruções
Processador CISC RISC SET de instruçõesProcessador CISC RISC SET de instruções
Processador CISC RISC SET de instruçõesCarlos Pereira
 
2-nocoes-basicas-algoritmos.pdf
2-nocoes-basicas-algoritmos.pdf2-nocoes-basicas-algoritmos.pdf
2-nocoes-basicas-algoritmos.pdfAlbertoEmoto
 
Relatório multiplexadores e decodificadores
Relatório multiplexadores e decodificadoresRelatório multiplexadores e decodificadores
Relatório multiplexadores e decodificadoresFlavio Oliveira Rodrigues
 
Curso de ShellScript - Lm05 shellscript5
Curso de ShellScript - Lm05 shellscript5Curso de ShellScript - Lm05 shellscript5
Curso de ShellScript - Lm05 shellscript5Pessoal
 

Similar a Cool 3 assembly para linux (20)

Stack based overflow
Stack based overflowStack based overflow
Stack based overflow
 
Aula 7 conjunto de instrucoes
Aula 7   conjunto de instrucoesAula 7   conjunto de instrucoes
Aula 7 conjunto de instrucoes
 
Lógica de programação pascal
Lógica de programação   pascalLógica de programação   pascal
Lógica de programação pascal
 
Apostila para aprender sobre CPUs e tudo mais
Apostila para aprender sobre CPUs e tudo maisApostila para aprender sobre CPUs e tudo mais
Apostila para aprender sobre CPUs e tudo mais
 
Programação básica de microcontroladores
Programação básica de microcontroladoresProgramação básica de microcontroladores
Programação básica de microcontroladores
 
Prova 2012 2_p4_gabarito
Prova 2012 2_p4_gabaritoProva 2012 2_p4_gabarito
Prova 2012 2_p4_gabarito
 
Criando sua própria linguagem de programação
Criando sua própria linguagem de programaçãoCriando sua própria linguagem de programação
Criando sua própria linguagem de programação
 
Ac16 conjunto de instruções v2
Ac16   conjunto de instruções v2Ac16   conjunto de instruções v2
Ac16 conjunto de instruções v2
 
Python.pptx
Python.pptxPython.pptx
Python.pptx
 
Criando um sistema operacional básico
Criando um sistema operacional básicoCriando um sistema operacional básico
Criando um sistema operacional básico
 
O que mudou no Ruby 1.9
O que mudou no Ruby 1.9O que mudou no Ruby 1.9
O que mudou no Ruby 1.9
 
ArqOrgCom.ppt
ArqOrgCom.pptArqOrgCom.ppt
ArqOrgCom.ppt
 
Arq orgcom (1)
Arq orgcom (1)Arq orgcom (1)
Arq orgcom (1)
 
Alocação dinâmica em C
Alocação dinâmica em CAlocação dinâmica em C
Alocação dinâmica em C
 
Aula c++ estruturas de dados
Aula c++   estruturas de dadosAula c++   estruturas de dados
Aula c++ estruturas de dados
 
Resumo x86
Resumo x86Resumo x86
Resumo x86
 
Processador CISC RISC SET de instruções
Processador CISC RISC SET de instruçõesProcessador CISC RISC SET de instruções
Processador CISC RISC SET de instruções
 
2-nocoes-basicas-algoritmos.pdf
2-nocoes-basicas-algoritmos.pdf2-nocoes-basicas-algoritmos.pdf
2-nocoes-basicas-algoritmos.pdf
 
Relatório multiplexadores e decodificadores
Relatório multiplexadores e decodificadoresRelatório multiplexadores e decodificadores
Relatório multiplexadores e decodificadores
 
Curso de ShellScript - Lm05 shellscript5
Curso de ShellScript - Lm05 shellscript5Curso de ShellScript - Lm05 shellscript5
Curso de ShellScript - Lm05 shellscript5
 

Más de Luiz Vieira .´. CISSP, OSCE, GXPN, CEH

Más de Luiz Vieira .´. CISSP, OSCE, GXPN, CEH (13)

Webgoat como ferramenta de aprendizado
Webgoat como ferramenta de aprendizadoWebgoat como ferramenta de aprendizado
Webgoat como ferramenta de aprendizado
 
Segurança Física: Lockpicking
Segurança Física: LockpickingSegurança Física: Lockpicking
Segurança Física: Lockpicking
 
Android forensics the hard work
Android forensics   the hard workAndroid forensics   the hard work
Android forensics the hard work
 
Engenharia social
Engenharia socialEngenharia social
Engenharia social
 
Segurança nos ciclos de desenvolvimento de softwares
Segurança nos ciclos de desenvolvimento de softwaresSegurança nos ciclos de desenvolvimento de softwares
Segurança nos ciclos de desenvolvimento de softwares
 
Auditoria em sistemas linux - LinuxCon Brazil 2011
Auditoria em sistemas linux - LinuxCon Brazil 2011Auditoria em sistemas linux - LinuxCon Brazil 2011
Auditoria em sistemas linux - LinuxCon Brazil 2011
 
Forense Computacional com Software Livre
Forense Computacional com Software LivreForense Computacional com Software Livre
Forense Computacional com Software Livre
 
Análise de malware com software livre
Análise de malware com software livreAnálise de malware com software livre
Análise de malware com software livre
 
Webcast Luiz Vieira criptografia on-the-fly com software livre
Webcast Luiz Vieira criptografia on-the-fly com software livreWebcast Luiz Vieira criptografia on-the-fly com software livre
Webcast Luiz Vieira criptografia on-the-fly com software livre
 
Metasploit Framework: Software Livre para PoC de Vulnerabilidades
Metasploit Framework: Software Livre para PoC de VulnerabilidadesMetasploit Framework: Software Livre para PoC de Vulnerabilidades
Metasploit Framework: Software Livre para PoC de Vulnerabilidades
 
Introdução à linguagem python
Introdução à linguagem pythonIntrodução à linguagem python
Introdução à linguagem python
 
Trusted Computing e Software Livre FISL 11 - 2010
Trusted Computing  e Software Livre FISL 11 - 2010Trusted Computing  e Software Livre FISL 11 - 2010
Trusted Computing e Software Livre FISL 11 - 2010
 
Analysis of vulnerabilities in web applications - LinuxCon Brazil 2010
Analysis of vulnerabilities in web applications - LinuxCon Brazil 2010Analysis of vulnerabilities in web applications - LinuxCon Brazil 2010
Analysis of vulnerabilities in web applications - LinuxCon Brazil 2010
 

Cool 3 assembly para linux

  • 1. Oficina Assembly para Linux Por Luiz Vieira @HackProofing
  • 4. Organização do Sistema CPU Registradores Execução Controle Flags I/O Barramentos Memória
  • 5. Registradores • Uso geral: – EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP • Segmento: – CS, DS, ES, SS, FS, GS • Instrução: – EIP • Controle: – CR0, CR1, CR2, CR3, CR4
  • 6. Registradores • EAX = Extended Acumullator (registrador acumulador extendido) • EBX = Extended Base (registrador de base extendido) • ECX = Extended Couter (registrador contador extendido) • EDX = Extended Data (registrador de dados extendido) • ESI = Extended Source Index (registrador de índice de origem extendido) • EDI = Extended Destination Index (registrador de índice de destino extendido) • Em adição aos registradores de uso geral, temos os registradores especiais, que são: – EBP = Extended Base Pointer (Ponteiro de Base) – ESP = Extended Stack Pointer (Ponteiro de Stack/Pilha) – EIP = Extended Instruction Pointer (Ponteiro de Instrução) – EFLAGS
  • 7. Registradores • Uma coisa que precisamos ter sempre em mente, é que tanto como o EIP quanto o EFLAGS, só poderão ser acessados através de instruções especiais e bem específicas, diferente dos demais registradores. • O EBP sempre aponta para a base da pilha, e também é utilizado para acessar essa mesma pilha, apesar de também poder ser utilizado como um registrador comum (de uso geral). Já o ESP, aponta para a posição atual da stack (pilha) e é o 'offset' do SS (Stack Segment).
  • 8. Organização de um registrador para uso geral EAX 31 0 AX 31 16 15 0 AH AL 15 8 7 0 •EAX armazenaria, por exemplo, um valor fictício de 0x00000000. •AX, que é a parte alta de EAX, armazenaria 0x0000. •AH, é a parte alta de AX, enquanto AL é a parte baixa de AX (ambos são de arquitetura 8bits), e armazenam apenas 0x00 cada um.
  • 9. AT&T x Intel • Intel = • AT&T =
  • 10. AT&T x Intel • Na sintaxe Intel, uma instrução comum ficaria assim: – instrução destino, origem • Em AT&T é: – instrução origem, destino • Uma questão importante de se lembrar, é que na sintaxe AT&T, todos os registradores devem ser prefixados pelo símbolo %, enquanto que o valores literais, pelo símbolo $. Portanto, 100 é diferente de $100, onde o primeiro é um endereço de memória, e o segundo é um valor numeral. • Outro símbolo importante, é o '$0x' utilizado para referenciar hexadecimais.
  • 11. Primeiro programa #OBJETIVO: Programa simples que executa um exit e retorna um código de status para o kernel Linux #ENTRADA: nenhuma #OUTPUT: retorna um status código de status, que pode ser visto executando no terminal o comando: # echo $? # após a execução do programa #VARIÁVEIS: # %eax armazena o número da syscall # %ebx armazena o status retornado .section .data .section .text .globl _start _start: movl $1, %eax # esta é a syscall do kernel Linux para sair de um programa movl $0, %ebx # este é o status que retornaremos para o SO. # altere esse valor, e verá coisas diferentes ao executar # echo $? int $0x80 # isso chama o kernel para executar a syscall 1
  • 12. Execução • Salve este código como 'exemplo1.s', compile e linkedite-o: # as exemplo1.s -o exemplo1.o # ld exemplo1.o -o exemplo1 Após este processo, para executar nosso primeiro programa, basta digitar no terminal: # ./exemplo1
  • 13. Explicação • .section .data = cria a seção "data", onde listamos quaisquer containers de memória. • .section .text = seção onde inserimos as instruções a serem executadas. • .globl _start = '.globl' é uma instrução que diz que o símbolo '_start' não deve ser descartado após a compilação e linkedição do código. • _start: = é onde definimos o valor do label '_start', que terá vinculado à si, o conjunto de instruções que seguem logo abaixo. • movl $1, %eax = aqui temos a instrução 'movl', seguido de dois operadores. Nesse caso, inserimos o valor 1 no registrador EAX. Esse número é o valor de uma syscall específica (exit - para conhecer os valores das demais 'syscall', execute o comando "cat /usr/include/asm- i386/unistd.h" no terminal Linux*). • movl $0, %ebx = inserimos o valor "0" no registrador EBX. Isso é o que dirá para o kernel que está tudo ok para o 'exit' ser executado. • int $0x80 = 'int' é o mesmo que 'interrupt'. Uma interrupção corta o fluxo de funcionamento de um programa e passa o comando para o Linux, o que em nosso caso, fará com que o kernel execute a 'syscall 1 '(exit). E o valor '$0x80' é o número de interrupção utilizado para que essa passagem de controle para o Linux aconteça. * No Ubuntu, o arquivo está em: /usr/include/asm/unistd.h
  • 14. Segundo programa .data HelloWorldString: .ascii "Hello Worldn" .text .globl _start _start: movl $4, %eax # syscall write()* movl $1, %ebx # parâmetro da syscall para definir STDOUT (fd) movl $HelloWorldString, %ecx # local da mem. onde se encontra o container com a string (Buf) movl $12, %edx # tamanho da string (count) int $0x80 movl $1, %eax # syscall exit() movl $0, %ebx int $0x80 * Syscall write() = ssize_t write(int fd, const void *Buf, size_t count);
  • 15. Passagem de syscalls e argumentos • De que maneira podemos passar os valores de syscall e seus argumentos? – EAX – número da system call – EBX – primeiro argumento – ECX – segundo argumento – EDX – terceiro argumento – ESI – quarto argumento – EDI – quinto argumento
  • 16. Execução • Salve este código como 'exemplo2.s', compile e linkedite-o: # as exemplo2.s -o exemplo2.o # ld exemplo2.o -o exemplo2 Após este processo, para executar nosso primeiro programa, basta digitar no terminal: # ./exemplo2
  • 17. Tipos de dados • Espaço reservado em tempo de compilação (em .data): – .byte = 1 byte – .ascii = string – .asciz = string terminada em null – .int = integer de 32 bits – .short = integer de 16 bits – .float = número single com ponto flutuante – .double = número double com ponto flutuante • Espaço criado em tempo de execução (em .bss): – .comm = declara área comum da memória – .lcomm = declara área local comum da memória
  • 18. Terceiro programa .data HelloWorld: .ascii "Hello World!" ByteLocation: .byte 10 Int32: .int 2 Int16: .short 3 Float: .float 10.23 IntegerArray: .int 10,20,30,40,50 .bss .comm LargeBuffer, 10000 .text .globl _start _start: nop movl $1, %eax movl $0, %ebx int $0x80
  • 19. Execução • Salve este código como 'exemplo3.s', compile e linkedite-o: # as –gstabs exemplo3.s -o exemplo3.o # ld exemplo3.o -o exemplo3 Após este processo, para executar nosso primeiro programa, basta digitar no terminal: # ./exemplo3 • # gdb ./exemplo3
  • 20. Execução • (gdb) list • (gdb) break *_start+1 • (gdb) run • (gdb) info variables • (gdb) help x • (gdb) x/12cb [endereço de HelloWorld] • (gdb) x/1db [endereço de ByteLocation] • (gdb) x/1dw [endereço de Int32] • (gdb) x/1dh [endereço de Int16] • (gdb) x/1fw [endereço de Float] • (gdb) x/5dw [endereço de IntegerArray] • (gdb) x/10db [endereço de LargeBuffer] • (gdb) x/100db [endereço de LargeBuffer]
  • 21. MOVx • É uma das instruções mais utilizadas em Assembly • Sua utilização é basicamente a seguinte: – movx origem, destino – movl  movimenta valores de 32bits movl %eax,%ebx – movw  movimenta valores de 16bits movl %ax,%bx – movb  movimenta valores de 8bits movl %ah,%bh
  • 22. Movendo dados • Entre registradores: movl %eax, %ebx • Entre registradores e memória: local: .int 10 movl %eax, local movl local, %ebx
  • 23. Movendo dados • Valor direto no registrador: movl $10, %ebx • Valor direto na memória: local: .byte 0 movl $10, local
  • 24. Movendo dados • Em um endereço indexado da memória: IntegerArray: .int 10, 20, 30, 40, 50 • Para selecionar o 3º valor da integer (30) – BaseAddres(offset, index, size) = – IntegerArray(0, 2, 4) movl %eax, IntegerArray(0, 2, 4)
  • 25. Quarto programa .section .data string: .string "Digite algo:n" tam: .long . - string .section .text .globl _start _start: movl $4, %eax # insere o valor 4, para a chamada da syscall write no EAX movl $1, %ebx # passa o parâmetro da syscall 4 para que algo seja exibido leal string, %ecx # carrega o endereço de memória do ECX e exibe o conteúdo de string movl tam, %edx # armazena o valor de tam no EDX int $0x80 movl %esp, %ecx # Salva o Stack Pointer em %ecx subl $10, %esp # Reserva 10 bytes para o usuario digitar no stack movl $3, %eax # insere o valor da syscall read (3) no EAX movl $9, %edx # Tamanho do que vai ser lido para EDX int $0x80 movl %eax, %edx # Move o que foi digitado para EDX. movl $4, %eax # syscall write movl $1, %ebx int $0x80 movl $0x1, %eax movl $0x0, %ebx int $0x80
  • 26. Execução • Salve como 'leia.s'. • Compile, linkedite e execute: # as leia.s -o leia.o # lf leia.o -o leia # ./leia
  • 27. Quinto programa .section .data string1: .string "Criar um arquivo e inserir conteúdo n" tam1: .long . - string1 string2: .string “Viva o Linuxn" tam2: .long . - string2 arq: .string "/tmp/arquivo.txt" .section .text .globl _start _start: movl $4, %eax # syscall write movl $1, %ebx leal string1, %ecx movl tam1, %edx int $0x80 movl $5, %eax # syscall open (5) movl $arq, %ebx # arquivo que será aberto movl $03101, %ecx # modo do arquivo movl $0, %edx # Permissão 0 int $0x80
  • 28. Quinto programa movl %eax, %esi # Move o retorno da funcao open para ESI movl $4, %eax # syscall write, para efetuar a escrita no arquivo movl %esi, %ebx # local de escrita, arquivo.txt leal string2, %ecx # escrita do conteúdo de string2 para dentro do arquivo movl tam2, %edx # O tamanho da variavel int $0x80 movl $6, %eax # syscall close (6) movl %esi, %ebx # Fecha o arquivo int $0x80 movl $1, %eax movl $0, %ebx int $0x80
  • 29. Execução • Salve como ‘escreva.s'. • Compile, linkedite e execute: # as escreva.s -o escreva.o # lf escreva.o -o escreva # ./escreva
  • 30. Comparação – Sexto programa .section .data data_items: .long 3,67,34,222,45,75,54,34,44,33,22,11,66,0 .section .text .globl _start _start: movl $0, %edi # insere 0 no registrador índice movl data_items(,%edi,4), %eax # carrega o primeiro byte de dados movl %eax, %ebx # como este é o primeiro item, %eax é o maior start_loop: cmpl $0, %eax # verifica se alcançamos o final je loop_exit incl %edi # carrega o próximo valor movl data_items(,%edi,4), %eax cmpl %ebx, %eax # compara valores jle start_loop # pula para o loop se o novo valor não for o maior movl %eax, %ebx # grava o valor como o maior jmp start_loop # pula para o início do loop loop_exit: # %ebx é o código de status para a syscall exit # e já possui o valor mais alto movl $1, %eax int $0x80
  • 31. Execução • Salve como ‘maximo.s'. • Compile, linkedite e execute: # as maximo.s -o maximo.o # lf maximo.o -o maximo # ./maximo # echo $?
  • 32. Condicionais • je – Pula (Jump) se os valores são iguais • jg – Pula se o segundo valor for maior que o primeiro • jge – Pula se o segundo valor for maior ou igual ao primeiro • jl – Pula se o segundo valor for menor que o primeiro • jle – Pula se o segundo valor for menor ou igual ao primeiro • jmp – Pula não importa o resultado da comparação (se houver uma). Esse Jump não precisa ser precedido por uma comparação • OBS: uma condicional normalmente é precedida por um cmpl (comparando dois valores): cmpl $0, %eax je loop_exit
  • 34. Contatos Luiz Vieira http://hackproofing.blogspot.com http://www.oys.com.br luizwt@gmail.com luiz.vieira@oys.com.br luiz.vieira@owasp.org