Assembly no Linux/Exemplos de uso de syscalls

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Outra semelhança com os procedimentos usados para o DOS. Temos o compilador (nasm) e o linker (Id), portanto primeiro será gerado um arquivo objeto, com extensão. O e, depois, com o uso do linker Id, será transformado em um executável. Com uma pesquisa no manual do Id (man Id) você pode aprender um pouco mais sobre suas opções e recursos. Agora as opções utilizadas são somente as necessárias para gerarmos um arquivo executável.

Hello world[editar | editar código-fonte]

Qualquer introdução a uma linguagem, compilador ou qualquer ferramenta ligada à programação não é completa sem o exemplo do hello world. Neste exemplo seguimos o seguinte raciocínio.

Temos para cada processo no Linux, três file descriptors que são criados e definidos automaticamente, que são: stdin, stdout, e stderr. Um file descriptor é um código que indica um arquivo. No nosso caso os arquivos são, respectivamente: entrada padrão do terminal. Em um programa em C podemos fazer o seguinte: write (1, “oi”, 2); que teremos como saída na tela a palavra “oi”.

Isto se explica por que escrevemos (write) no arquivo indicado pelo fd (file descriptor) número 1, uma string de 2 caracteres.

Seguindo este raciocínio, vemos que não tem uma syscall chamada print, como a maioria pode esperar, mas sim, a SYS_write. Portanto, traduzindo para assembler a linha acima, teremos impressa a string que queremos na tela.

Esta syscall pede três parâmetros a seguir: ebx com o numero do file descriptor (no nosso caso 1, stdout), ecx um ponteiro (endereço da memória) para a string e edx o tamanho da mensagem. O registro eax deve estar carregado com o valor 4, que na tabela corresponde a SYS_exit, para sair corretamente do programa, avisando o kernel para limpar os recursos usados. O registro eax é carregado com 1 (código de SYS_exit), e int 0x80 é chamada novamente, finalizando assim o programa.

; Exemplo 1
; hello world em assembly
; usando syscalls [ int 0x80 ]
;
;
; compilar com nasm –f elf hello.s
; linkar com ld –s –o hello hello.o
;
 
Section .text         align=0
Global _start                       ; inicio Do programa para o mundo é _start
msg        db           Hello World , 0x0a ;mensagem + LF, para pular a linha
len        equ          $ - msg   ; tamanho da mensagem
 
_start:                                    ; entrypoint Ponto de execução inicial
 
 
                mov eax,4                  ; número da função [SYS_write] write
                mov ebx,1                  ; número Do fd [ file descriptor ] no caso, Stdout
                mov ecx,msg                ; ponteiro da mensagem
                mov dx,len                 ; tamanho da mensagem
                ; write [1, msg, len];
                int 0x80  ; syscall
 
                mov eax,1                  ; número da função [SYS_exit] exit
                mov ebx,0                  ; parâmetro do sys_exit (0=OK, 1=Erro)
                int 0x80                   ; chamada do kernel
                ; Fim do código

Lê parâmetros da linha de comando e os imprime[editar | editar código-fonte]

Este segundo exemplo, um pouco mais elaborado, lê os parâmetros passados pela linha de comando, limpa a tela e imprime-os. Novamente, a criatividade de ser usada para suprir nossas necessidades.

Quando executamos um programa, do tipo ./programa parm1parm2, após as inicializações do kernel, quando o controle é entregue à primeira função do programa, normalmente chamada start ou main, temos a pilha da maquina (stack) e os registros com alguns valores carregados, tais como parâmetros de linha de comando, variáveis de ambiente, em suma, o que receberíamos na função main de um programa em C:

Int main (int argc, char**argv, char**envp);,

Onde argc, é o numero de argumentos passados pela linha de comando, argv uma matriz de ponteiros para os argumentos, terminada em NULL e envp uma matriz de ponteiros para as variáveis de ambiente.

Todos estes dados estão no stack, na seguinte ordem: argc, todos os ponteiros argv, seguidos por um NULL, e todos os ponteiros envp seguidos por um NULL.

Portanto, para recuperarmos estes dados, simplesmente vamos retirando (instrução pop) os valores do stack, e tratando-os.

Reparem que no início do programa, algumas strings são definidas, tais como LF (line feed), para mudarmos de linha e uma string ANSI, com o código que limpa a tela. Não temos uma syscall que faz isso, nem faria muito sentido, visto que o terminal é apenas uma das interfaces que podemos encontrar em um ambiente Unix. N maioria dos terminais, que é comparável com ANSI, este código surte efeito. No DOS, dependendo da versão, deveríamos usar o driver ANSI.SYS no confing.sys, para que tais códigos fossem interpretados. É com uma solução semelhante a esta que fizemos o HOME, ou seja, a função que faz o cursor se posicionar nas coordenadas 0,0, canto superior esquerdo da tela.

Note que após clrs e home, já calculamos os respectivos tamanhos, pois as imprimiremos com a técnica usada no Exemplo 1, SYS_write e stdout.

Assim, com a tela limpa e o cursor em (0,0), o processamento é iniciado com a checagem do número de parâmetros, se não forem passados nenhum parâmetro, o programa deve sair imediatamente. Caso contrario, deve haver um loop que enquanto eles não terminem(testando se é NULL), é neste loop que será calculado o tamanho de cada um e impresso na tela, usando a técnica do exemplo anterior. Ao final, SYS_exit é chamada.

Verifique o uso intensivo de loops e labels, que apesar de parecerem complexos, guardam uma lógica bem simples, como usar o registro que deve passar o parâmetro de tamanho da string para SYS_write, como acumulador no loop que calcula este dado (strlen). Assim, ao final do loop, o parâmetro já esta correto e economiza mais trabalho.

Este exemplo é bem mais elaborado, mas serve para ilustrar as possibilidades existentes.

; Exemplo 2
;
; limpa a tela
; passagem de parâmetros por linha de Comando
; imprime o que foi passado
; muda de linha
;
; os parâmetros são pegos do stack
;
;
; compilar com : nasm –f elf prog.s
; linkar com            : ld –s –o prog prog.0
;
;
Section  .text        align=0
Global                   _start
 
; crlf – representa os códigos para mudar de linha e retornar ao início
line                        de 0x0a
len                         que $ - line
; limpa a tela usando códigos ANSI
 
clrs                         db 0x16, [2J
clslen                                    equ $ - clrs
 
; vai para 0,0, ocm um bkspace
; usando ANSI
 
home                     db 0x16, [0H , 0x16,
  [0C , 0x08
holen                     equ $ - home
 
; início
 
 
_start:
 
 
; limpa a tela
 
                mov eax, 4             ; write
                mov ebx, 1             ; stdout [fd]
                mov ecx, clrs        
                mov edx, clslen
                int 0x80                  ; syscall
 
 
; início do processamento
 
 
                Pop eax  ; testa argc,para verificar se existem parametros
                Dec eax  ;
                Jz exit                     ; se não existem, sai do programa
                pop ecx
                                               ; note q argv [0] é sempre o nome do programa.
                                               ; como não queremos que ele apareça,
                                               ; faremos o stackpointer andar [o índice do stack] até argv [1]
 
 
;  Loop executado até que todos os argumentos sejam impressos
mainloop:                            ; lavel do loop principal
 
                pop ecx; pega parametro
                ore cx, ecx             ; testa se é zero [NULL]
                Jz exit     ; ecx        ; goto [ ble ] Exit
 
                mob rdi, ecx
                xor edx, edx
 
.strlen:
encontra o tamanho da string deste argumento [argv[]]
                ince dx                   ; esta é uma versão simples de strlen, que conta cada caractere
                lodsb                     ; de uma string até o seu final [\0]
                or AL, AL
                jnz .strlen
                dec edx
 
                mov eax, 4             ; write
                mov ebx, 1             ; stdout
                int 0x80                  ; syscall
; pula linha após escrever
 
                mov eax, 4
                mov ebx, 1
                mov cx,  line
                move dx, len
                int 0x80
 
                jmp mainloop      ; continua
 
exit:
                move ax, 1             ; final do programa
                int 0x80                  ; syscall
;
;
; Fim do código

Usando bibliotecas com código Assembly[editar | editar código-fonte]

Além de usar diretamente as syscalls, podemos também nos aproveitar das muitas bibliotecas (libraries) presentes em nosso sistema, para aliar a velocidade do Assembly com a praticidade de rotinas prontas. Basicamente, isso significa passar os argumentos no stack e chamar a rotina desejada usando call. Na hora de linkar, devem ser indicadas as bibliotecas corretas, ou no caso da libc, o Id automaticamente pode linkar da forma correta.

O procedimento para compilação muda um pouco, porque usaremos o gcc para nos ajudar a linkar e resolver as pendências de bibliotecas em vez do Id, que exigiria mais parâmetros em linhas de comando. Na realidade o gcc vai usar o Id, mas nos poupará trabalho. A única mudança neste caso, é trocar de_start para main, para que o gcc entenda que este é o ponto de entrada.

Usando libc[editar | editar código-fonte]

Neste exemplo, simplesmente utilizamos uma chamada à função printf, da libc, para imprimir nossa string, em vez de imprimi-la caractere a caractere usando SYS_write. Quando chamamos uma função de uma biblioteca, seus parâmetros devem estar em ordem, na pilha.

; Exemplo 3
; Hello World usando libc [prinft]
; compilar com nasm –lelf hello-world.s
; linkar com gcc –s 0o hello-word hello-word.o
;
 
extern printf                         ; declara printf como um símbolo externo
global main                         ; avisa q main é um ponto de entrada visível
                               ; ao mundo externo do programa.
 
section .text
main:
                               puxha                                    ; Salva todos os registros
push dword messsage                      ; Coloca o ponteiro da mensagem no stack
                call printf                                                             ;
                add esp, 4                                            ;
                popa                                                     ; restaura seus valores
                ret                                                          ; retorna
 
message: db “hello, world!”, 10, 0
 
;
; Fim do código
;