Criptografia e Segurança das Comunicações

(1)

Criptografia e Segurança

das Comunicações

Tópicos de Assembly86

Assembly86 : 1/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Introdução (1)

• As linguagens Assembly, desenvolvidas a partir dos anos

50, são referidas como linguagens de 2ª geração.

– Vantagens: programas mais rápidos, ocupando menos memória. – Inconvenientes: reduzida produtividade, obriga programadores a

manipular recursos de baixo nível – ex: gestão de registos.

• Actualmente a programação Assembly ainda é usada em

Curiosidade, não faz parte da avaliação

• Actualmente a programação Assembly ainda é usada em

diversos casos:

– Programação de gestores de dispositivos (“device drivers”). – Programação de sistemas de recursos limitados – ex: sistemas

embutidos (“embedded systems”). – Desenvolvimento de compiladores. – Sistemas criptográficos, designadamente

• Uso de instruções especializadas – ex: rotação de dados

• Garantia de gasto igual de tempo, a fim de evitar ataques baseados no tempo de execução.

(2)

Introdução (2)

Linguagem Alto Nível (HLL – ex: C) Linguagem Assembly (ex: Asm86) Compilador v[i] = 2; LEA BX,$v MOV DX,$i MEEC:Programação MEEC: Criptografia e Segurança das Comunicações

(ex: Asm86) Linguagem máquina Especificação controlo sinais Assembler Interpretação processsor MOV DX,$i MOV AX,2 MOV [BX+DX],AX 0000 1001 1100 0110 1010 1111 0101 1000 1010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111

ALUOP[0:3] <= InstReg[9:11] & MASK

MEEC:Arquitectura de Computadores

Introdução (3)

• Para Windows a Microsoft desenvolveu o MASM611

– ML /c fich.asm

• Gera ficheiro objecto de extensão .OBJ • Opção /Fl gera listagem

– LINK fich1+fich2 ,,,,,

• Por omissão, gera fich1.EXE

• Por omissão, gera fich1.EXE • Opção /t gera ficheiro .COM

Nota: O MASM é orientado a 32 bits, pelo há problemas na execução do LINK de aplicações a 16 bits no Windows Vista/7. Sugere-se correr no emulador DOS-Box disponível em http://www.dosbox.com

• Para Linux usar o NASM (http://nasm.sourceforge.net)

• GAS (GNU Assembly Syntax) usada pelo gcc.

Nota: o MASM e o NASM adoptam a sintaxe Intel, GAS adopta a sintaxe AT&T.

(3)

Lista processadores Intel (1)

• Processadores IA-16

1978: 8086-29K transistores, 0.33 MIPS endereça 1MB.

1982: 80286-134K transistores (MMU incorporado), 0.9 MIPS endereça 16MB de memória.

• Processadores IA-32

1985: 80386-275K transistores, 5 MIPS endereça 4GB de memória.

1985: 80386-275K transistores, 5 MIPS endereça 4GB de memória. 1989: 80486-1.2M transistores (FPU incorporado), 50 MIPS.

1993: Pentium-3.1M transistores, 60 MIPS [introduz SIMD instruções em registos de 64 bits].

1997: Pentium II- 9.5M transistores, 300 MIPS.

1999: Pentium III-9.5M transistores, 500 MIPS [introduz Streaming SIMD instruções em registos de 128 bits].

2000: Pentium 4-42M transistores, 1500 MIPS endereça 64GB de memória.

• Processadores IA-64

2006: Core 2-151M transistores, 20_000 MIPS.

Lista processadores Intel (2)

• Na passagem de 32 bits para 64 bits, os fabricantes

seguiram abordagens distintas:

– Intel associou-se à HP para desenvolver processador Itanium dedicado a servidores e a estações de trabalho de elevado desempenho. O processador emulava o IA-32, mas com significativa degradação no desempenho.

significativa degradação no desempenho.

– Advanced Micro Devices desenvolveu AMD64, estendendo o IA-32 (16 registos de uso geral de 64 bits)

• Vendas do AMD64 muito superiores levaram a Intel a

adoptar a arquitectura AMD64, sob a designação EM64T.

Informação complementar do IA32 e IA64 disponível em

(4)

Pentium – arquitectura (1)

• O Pentium adopta arquitectura CISC

– reduzido número de registos de uso geral.

– elevado número de instruções do tipo registo-memória (uma dos argumentos pode ser memória).

• Por compatibilidade, o Pentium mantém as características

dos antecessores (8086/8,80286,…)

– Segmentação de memória, em dois modos. – Registos de uso geral acedidos a 8, 16 e 32 bits.

• A inércia (8086 foi único processador de 16 bits durante 2

anos) e ter sido adoptado pelo IBM-PC levaram vendas

muito superiors aos competidores tecnologicamente

superiores.

Pentium – arquitectura (2)

• Core incorpora a arquitectura RISC

– Maior número de registos de uso geral (16 contra 8 do IA-32). – Registos passam a ser ortogonais:

• Multiplicação deixa de ser restrita a EDX:EAX.

• Acesso na parte inferior de 8 bits a todos os registos (ex: DIL, SIL,

• Acesso na parte inferior de 8 bits a todos os registos (ex: DIL, SIL, SPL, R8L)

• Nota: alguns registos continuam a ser dedicados, como o SP.

• Para continuar a executar imenso código desenvolvido,

Core disponibiliza dois modos:

– Compatível IA-32, com aplicações a aceder espaço de 4GB. – 64 bits, com instruções de prefixo REX a aceder às extensões de

(5)

Pentium – arquitectura (3)

• Distribuição das componentes de um programa no

Pentium

Pilha(“stack”) SP EBP Arena(“heap”) Assembly86 : 9/87 Prof RG Crespo Criptografia e Segurança das Comunicações

EAX EBX ECX EDX

CS Arena(“heap”) SS _Dados estáticos DS Código EIP EDI ESI

Registos uso geral

Registos segmento

Pentium: registos

• O Pentium possui registos dedicados a diversas funções :

– 8 de uso geral (“general purpose”) para operações aritméticas, lógicas e de endereçamento.

– 1 contador de programa (“program counter”).

– 6 de segmento (“segment”) para organização de memória

– 1 de bandeiras (“flags”) para controlo de execução do programa. – 8 de vírgula flutuante (“floating point”).

(6)

Registos: uso geral (1)

IA-32: Os registos de uso geral podem ser acedidos

individualmente na parte inferior

16-bit 32-bit

AH AL AX EAX

BH BL BX EBX

BH BL BX EBX CH CL CX ECX DH DL DX EDX BP EBP SI ESI DI EDI SP ESP Deslocamentos de blocos de memória

{

Registos: uso geral (2)

• Os registos de uso geral são usados para

– guarda temporária de expressões.

– endereçamento base de tabelas e de gamas de memória.

– execução de operações aritméticas (soma,…) e lógicas (AND, "shifts",…).

• As operações de multiplicação e de divisão trabalham com

valores de comprimento duplo (8086/8: 2*16=32 bits,

Pentium: 2*32=64 bits), que são guardados no par de

registos EDX:EAX (EDX contém os dígitos mais

significativos).

(7)

Registos: uso geral (3)

• EIP: utilizado como ponteiro para a próxima instrução a

executar: este registo não é controlável directamente pelo

programador.

• EBX,EBP: utilizados como endereço base de tabela

– EBX no segmento de dados (onde residem variáveis globais) – EBX no segmento de dados (onde residem variáveis globais) – EBP no segmento de pilha (onde residem os parâmetros e

variáveis locais às rotinas)

• ESI,EDI: utilizados como deslocamentos a partir de um

registo base (ESI indica deslocamento de uma fonte e EDI

indica deslocamento de um destino).

Registos: uso geral (4)

• ESP: utilizado como ponteiro base da pilha (endereço da

primeira posição livre da pilha).

• EBP: utilizado para acesso aos parâmetros [EBP+desl] e

às variáveis locais [EBP-desl].

Parâmetros EBP Sentido do PUSH ESP Posições livres Variáveis locais End. retorno Registos

Espaço obtido por subtracção de ESP

(8)

Registos: uso geral (5)

IA-64: Os registos de uso geral dependem do modo

seleccionado.

– Compatível IA32

• 8 registos iguais aos IA32: EAX-EDX, EDI,ESI, EBP, ESP • 8 registos extra: R8D-R15D

• 8 registos extra: R8D-R15D

– 64 bits

• 8 registos iguais aos IA32, mas com prefixo R: RAX-RDX, RDI,RSI, RBP, RSP

• 8 registos extra: R8-R15

• Todos os registos podem ser acedidos ao Byte, Word,

Double e Quad (só em modo compatível 64-bit).

Registos: uso geral (6)

Tipo registo Modo compatível IA32 Modo 64-bit

Byte AL,BL,CL,DL, AH,BH,CH,DH AL,BL,CL,DL, DIL,SIL, BPL,SPL, R8L-R15L

Word AX,BX,CX,DX, AX,BX,CX,DX,

Word AX,BX,CX,DX, DI,SI, BP,SP AX,BX,CX,DX, DI,SI, BP,SP, R8W-R15W Double EAX,EBX,ECX,EDX, EDI,ESI, EBP,ESP EAX,EBX,ECX,EDX, EDI,ESI, EBP,ESP, R8D-R15D Quad -- RAX,RBX,RCX,RDX, RDI,RSI, RBP,RSP, R8-R15

(9)

Registos: bandeiras (1)

• O Pentium possui o registo EPFLAG, com 17 bandeiras

("flags").

– Alguns dos bits são modificados pelo CPU por forma a refletir o estado ("status") da ultima instrução lógica ou aritmética.

– Há instruções específicas para alterar valor de algumas bandeiras (ex: CLD limpa registo DF)

(ex: CLD limpa registo DF)

• Diversas instruções permitem transferir o controlo do

programa de acordo com o valor de bandeiras (ex: salto

condicional).

• Bandeiras DF, IF e TF permitem controlar a operação do

processador (ex: DF incrementa/decrementa valor de

EDI:ESI na instrução MOVSx).

Registos: bandeiras (2)

Nome Função

CF Carry flag. Colocado a 1 se houver transporte ou empréstimo.

PF Parity flag. Colocado a 1 se os 8 bits inferiores tiverem número par de 1's.

AF Auxiliary carry flag. Colocado a 1 se houver transporte ou empréstimo dos 4 bits

inferiores de AL

ZF Zero flag. Colocado a 1 se o resultado for nulo

SF Sign flag. Igual ao bit mais significativo

TF Trap flag.

IF Interrupt flag.

DF Direction flag.

OF Overflow flag. Colocado a 1 se o resultado não puder ser expresso dentro do

(10)

Registos: vírgula flutuante

• O Pentium possui o conjunto ST de 8 registos de 80 bits,

para vírgula flutuante

– ST manipulado como pilha

• Carregamento feito pela instrução FST val em vez de MOV reg,val

MOV reg,val

• Adição FADD manipula conteúdo dos registos no topo da pilha

– Registo FPUstatus indica estado corrente da unidade de processamento

– Números representados pela norma IEEE 754

• Zero • Infinito

• Denormais (próximos do zero) • NAN (“Not A Number”) - ex: √-1

Modos de operação (1)

• [Def] Um modo de operação é o conjunto elementos do

estado interno do processador que afectam o

comportamento da execução.

Cada arquitectura é isolada no modo de operação.

• O 8086/8 tem apenas um modo de operação (real). Os

microprocessadores seguintes permitem executar código

escrito para um microprocessador anterior, por selecção

do modo de operação correspondente.

(11)

Modos de operação (2)

A. Modo real

– Único disponibilizado pelo 8086.

– Endereço efectivo EA-”Effective address”, determinado por:

1. Deslocar segmento 4 bits para a esquerda

2. Somar deslocamento (“offset”) 0fffffh

2. Somar deslocamento (“offset”)

Ex: CS=01200h, IP=03f7h Endereço efectivo = 021000h+03f7h = 0123f7h 00000h 0fffffh Segmento 64KB

EA

offset

Modos de operação (3)

• Os registos 8086/8 têm 16 bits, endereçando apenas

64KB.

• Os registos de segmentos permitiram aumentar o espaço

de endereçamento para 20 bits (1MB). No 8086 são

disponibilizados 4 registos de segmento:

– CS (Code Segment) para instruções – DS (Data Segment) para variáveis globais

– SS (Stack Segment) para pilha (parâmetros de rotinas e variáveis locais)

– ES (Extra Segment)

(12)

Modos de operação (4)

• Por omissão, as instruções usam determinado registo de

segmento para cálculo do endereço efectivo

– Acesso a instrução: CS

– PUSH/POP: SS para endereço efectivo de memória – MOV: DS para endereço efectivo de memória – MOV: DS para endereço efectivo de memória

• [BX]: DS para endereço efectivo de memória • [BP]: SS para endereço efectivo de memória

• Pode-se contornar o segmento por omissão, indicando

outro registo no prefixo da instrução na forma xS:

Ex: MOV AX,ES:[$var]

Prefixo

Modos de operação (6)

B. Modo protegido

– Disponibilizado pelo 80286, com CS=DS=SS.

– O registo de segmento indexa tabela, LDT ou GDT, com entradas a 64 bits que contêm

• Endereço base

_Endereço

• Endereço base • Limite superior • Descritores 13 bits Limite superior Endereço base Descritores

Endereço

EA

Segmento

32bits 32bits

• LDT-”Local Descriptor Table”, uma por processo

(13)

Modos de operação (7)

• No Pentium, o limite é indicado por 20 bits

• Descritores determinam diversas propriedades:

– Modo de acesso à memória (leitura apenas – para código, leitura e escrita – para dados)

– Bit D : dimensão dos dados

• D=0 : instruções de 16 bit • D=1 : instruções de 32 bit

– Bit de granularidade

• G=0 : o processo pode aceder entre 1B e 1 MB. • G=1 : o processo pode aceder entre 4KB e 4GB

– …

Modos de operação (8)

C. Modo plano (“flat”)

– Disponibilizado pelo 80386, com CS=DS=SS.

– Os registos de 32 bits acedem ao espaço, designado endereçamento linear, de 232 _{= 4GB.}

• No IA64, modo 64-bit, o endereçamento linear depende da • No IA64, modo 64-bit, o endereçamento linear depende da

implementação (a primeira cobre 48 bits).

• O endereço deve ser canónico, com bits mais significativos fora do endereçamento linear inverso do bit mais significativo do

endereçamento linear.

(14)

Modos de operação (9)

• O endereço virtual é depois transcrito, pelo µP, para endereço físico

por paginação.

Modos de endereçamento (1)

[Def] Um modo de endereçamento é uma forma que o

microprocessador usa para aceder aos dados.

O Pentium disponibiliza 5 modos de endereçamento de

operandos e 9 derivados.

1. Registo

PUSH CX ; 16 bits POP EAX ; 32 bits

(15)

Modos de endereçamento (2)

2. Imediato: valor indicado na própria instrução.

O espaço do valor é determinado pelo registo. Nas

instruções envolvendo memória, o espaço do valor tem de

ser indicado por directivas PTR: Byte-1, Word-2, Dword-4:

MOV EAX,0h ; 32 bits MOV EAX,0h ; 32 bits PUSH Byte PTR 0 ; 8 bits

3. Directo

: localização por identificador de variável

A localização pode ser deslocada

[var+Base+índice*escala+deslocamento]

– Reg base: {EAX,EBX,ECX,EDX,ESP,EBP,ESI,EDI} – Reg índice: diferente registo base, excluindo ESP – Escala: {1,2,4,8}, 1 por omissão

(modo de endereçamento suportado a partir do 386)

Modos de endereçamento (3)

Exemplos:

Instrução Significado

PUSH Byte PTR [$m+1] Insere na pilha Byte de endereço seguinte a $m PUSH Word PTR [$m+EAX*2] Insere na pilha Word de uma tabela $m no

índice indicado em EAX*2

PUSH Byte PTR [$m+EDX+EBP] Insere na pilha Byte de endereço $m mais soma dos conteúdos de EDX e de EBP

• O 8086 adopta estratégias distintas na determinação do

valor nos endereçamentos imediato e directo com etiqueta

– Instruções salto (JMP,...) e chamada a rotina (CALL): o valor é o deslocamento relativo ao registo IP.

– Directo: o valor é o deslocamento relativo ao segmento de dados

(16)

Modos de endereçamento (4)

• Indirecto: endereço determinado a partir do valor de

registos, não sendo indicada variável.

Há 3 designações de endereçamento indirecto, conforme os registos usados:

– Base: apenas {EBX,EBP}, com eventual deslocamento. – Indexado: apenas {EDI, ESI}, com eventual deslocamento. – Indexado: apenas {EDI, ESI}, com eventual deslocamento. – Base indexada: indicados registos base e índice, com eventual

deslocamento.

• Podendo o mesmo registo ser base ou índice, que designação usar no endereçamento indirecto quando apenas se usa 1 registo?

– Se for indicada escala, ex: PUSH [EBX*2], o modo é indexado. – Para os registos ESI e EDI, ex: PUSH [ESI+1], o modo é indexado. – Os restantes casos são designados por modo base.

Modos de endereçamento (5)

5. Bloco: usado no deslocamento de sequências de dados de

grande dimensão.

– Cadeia fonte apontada por DS:SI

– Cadeia destino apontada por ES:DI

Mnemónica Código Segmento Operação simbólica MOVSB A4 ES,DS [ES:EDI]<− [DS:ESI]

If DF=0 then ESI<-ESI+1;EDI<-EDI+1; If DF=1 then ESI<-ESI-1;EDI<-EDI-1; Controlo exercido por instrução de repetição (ex: LOOP label)

(17)

• Operação • Destino • Byte/Word

Formato de instruções

• As instruções variam entre 1 e 17 B

Mod Reg r/m

disp-high disp-low

Prefixo Opcode Mode SIB

• Scale • Index • Base Operando • Byte/Word Assembly86 : 33/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Byte/Word Mod Reg r/m

0-Byte 00-disp ausente 00-ES 000-EA=(EBX)+(ESI)+Disp 1-Word 01-disp low estendido 01-CS 001-EA=(EBX)+(EDI)+Disp 10-disp high/low presentes 10-SS 010-EA=(EBP)+(ESI)+Disp

11-DS 011-EA=(EBP)+(EDI)+Disp 100-EA=(ESI)+Disp 101-EA=(EDI)+Disp 110-EA=(EBP)+Disp 111-EA=(EBX)+Disp • Base

Estrutura do programa

• As instruções do programa Asm86 possuem a forma

[nome] mnemónica [operandos]

• As instruções podem começar em qualquer coluna e terminam obrigatoriamente por um NEWLINE.

obrigatoriamente por um NEWLINE.

• Comentários depois de ; e válidos até ao NEWLINE.

• As instruções possuem 0 (ex: NOP), 1 (ex: INC AX) ou 2 operandos (ex: ADD AX,10 ).

– Para 2 operandos, o primeiro actua simultâneamente como fonte e destino do resultado (Nota: semelhante ao C, na instrução compacta de atribuição

var += 10;).

Ex: ADD AX,10 a fonte e o resultado é o registo AX.

(18)

Segmentos lógicos (1)

[Def] Um segmento lógico

1

_{é um módulo que pode conter}

até os 3 componentes físicos de um programa (código,

dados e pilha).

name SEGMENT align combine 'class' name ENDS

• As opções align, combine e class definem instruções de

``loading´´

1_{não confundir com registo de segmento}

Segmentos lógicos (2)

• Para 16 bits no Asm86, os modos de programação

determinam o número de segmentos lógicos

– Tiny: CS (ficheiro de tipo .COM, os segmentos de código e de dados são combinados no CODE)

– Small: CS=DS=SS (apenas admitido um segmento de códigos e um segmento de dados)

segmento de dados)

– Medium: DS=SS e distinto de CS (apenas admitido um segmento de dados, pode haver vários segmentos de código)

– Large: (pode haver vários segmento de códigos e de dados)

ATENÇÃO

: o modo real em modo TINY é usado em CSC

para programação de virus e “buffer overflow”.

• Para 32 bits, o Asm86 disponibiliza

(19)

Segmentos lógicos (3)

Align

• define o alinhamento do segmento lógico, i.e., a gama de

endereços de memória a partir dos quais se poderá colocar

o início do segmento de programa

– BYTE qualquer endereço

– WORD qualquer endereço de palavra (i.e., endereço par) – PARA endereço de parágrafo (16 Bytes/parágrafo) – PAGE endereço de página (1024 Bytes/página)

Segmentos lógicos (4)

Combine

• Define o critério de combinação dos segmentos lógicos

que possuem o mesmo identificador

– PUBLIC Concatena todos os segmentos lógicos com o – PUBLIC Concatena todos os segmentos lógicos com o

mesmo nome. Todos os endereços de código e dados são relacionados no mesmo registo de segmento.

– STACK Concatena todos os segmentos lógicos com o mesmo nome. Todos os endereços são relacionados com SS

– COMMON Cria segmentos sobrepostos colocando o início de todos os segmentos que possuem o mesmo nome no mesmo endereço

(20)

Segmentos lógicos (5)

– MEMORY Coloca todos os segmentos que possuem o mesmo nome no maior segmento físico possível.

– AT addr Todas as etiquetas e endereços de variáveis são relacionados para o dado endereço: os segmentos AT não contêm código ou dados inicializados e representam acessos a ROM

ROM

Class

• determina os segmentos de programa que devem ser

colocados uns a seguir aos outros quando o editor de

ligações (“link”) agrupar todos os módulos.

Directivas (1)

End

• Todos os programas devem terminar por um END. Se na

directiva END for indicado um nome, ele é considerado

como o módulo principal.

_code SEGMENT PARA PUBLIC 'CODE' _code SEGMENT PARA PUBLIC 'CODE'

main PROC FAR ; ponto entrada do programa MOV EAX,data ; inicialização do DS MOV DS,EAX ; //

LEA ESP,_top ; inicialização do SP ;

_code ENDS END main

(21)

Directivas (2)

Assume

• Identifica registo de segmento seg-reg a usar como registo

de omissão para as etiquetas e variáveis definidas no

segmento de programa seg-name.

ASSUME seg-reg:seg-name,… ASSUME NOTHING

Exemplo:

ASSUME CS:_code, DS:_code, SS:_code

Cancela selecção existente

Todos os segmentos dentro do mesmo segmento lógico

Directivas (3)

Proc, Endp

• Delimitam rotinas

name PROC type …

name ENDP name ENDP

– O tipo da rotina pode ser NEAR (rotina chamada dentro do segmento) ou FAR.

– O nome da rotina pode ser usado como operando de instruções jump, call ou loop.

(22)

Directivas (4)

Org

• Inicializa o contador para a expressão (que deve ser um

numero absoluto).

_code SEGMENT PARA PUBLIC 'CODE' ORG 0100h

ASSUME CS:_code, DS:_code, SS:_code ASSUME CS:_code, DS:_code, SS:_code _main PROC NEAR ; ponto entrada do programa ; ; programa e dados ; _code ENDS END _main Assembly86 : 43/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Directivas (5)

Equ

• Constante na forma

name EQU valor

CR EQU 0dh CR EQU 0dh LF EQU 0ah DIM EQU 100 … _newline DB _{CR,LF,″$″} _data DB DIM DUP(0)

(23)

Macros (1)

[Def] Uma macro é uma inserção “inline” de código,

delimitado por macro … endm

$pushr MACRO ; salvaguarda registos na pilha push bp push bx push cx push dx push dx ENDM … $pushr

• Parâmetros podem ser usados

$writeS MACRO p1 mov dx, offset p1 mov ah,09h int 21h ENDM Assembly86 : 45/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Macros (2)

• Para evitar a duplicação de declarações, usadas para

etiquetas e variáveis, usar a declaração LOCAL

$test MACRO mark LOCAL failure,out mov ax,mark cmp ax,10 cmp ax,10 jl failure $writeS POS jmp out failure $writeS NEG out ENDM

(24)

Inteiros, Cadeias caracteres (1)

• Literais expressos na forma digitosR

– B (binários: 01b) – Q,O (octal)

– D (decimal, opção por omissão)

– H (hexadecimal, obrigatoriamente iniciado por dígito 0-9: 0ffh, – H (hexadecimal, obrigatoriamente iniciado por dígito 0-9: 0ffh,

42h)

• Cadeias de caracteres delimitas por plicas ou aspas. O

carácter delimitador pode ser inserido na string através da

sua duplicação (ex: 'don''t' )

Inteiros, Cadeias caracteres (2)

• Os operandos, inteiros ou endereços, são representados em

notação little-endian

– Bytes menos significativos nas localizações inferiores – Bytes mais significativos nas localizações superiores.

Nota

: a representação aplica-se apenas a cada dado atómico.

Nota

: a representação aplica-se apenas a cada dado atómico.

Para uma tabela/estrutura, a distribuição em memória é

big-endien.

• Vantagens do big-endien (Motorolla 68000)

– Representação próximo dos humanos

– Cadeias de caracteres e inteiros armazenados na mesma ordem

• Vantagens do little-endien (Intel 8086)

(25)

Inteiros, Cadeias caracteres (3)

Exemplos:

1. Representar o endereço 12345678

Endereço 00 01 10 11 Big Endian 12 34 56 78

2. Representar

dw 3 dup(1020h,3040h,5060h)

Endereço 000 001 010 011 100 101

Big Endian 10 20 30 40 50 60

Little Endian 20 10 40 30 60 50

Little Endian 78 56 34 12

Identificadores

• Iniciados por uma letra, _, ?, $ ou @

– Os compiladores geram identificadores próprios (ex: etiquetas) com prefixo inexistente na linguagem (ex: _)

– Os compiladores inserem prefixos extra (ex: $) nos identificadores de programas (variáveis, rotinas) para evitar conflitos com

instruções do Assembly instruções do Assembly

• Letras minúsculas convertidas para maiúsculas.

• Apenas são considerados os primeiros 31 caracteres.

(26)

Declaração de dados globais (1)

• O Asm86 disponibiliza 2 tipos de dados, básicos e

compostos

[name] ESP valor-inicial,…

Tipo ESP Espaço (bits) Tipo em C Byte DB 8 char(ASCII)

Palavra DW 16 short, char(UNICODE)

Duplo DD 32 int Quádruplo DQ 64 double

Declaração de dados globais (2)

• O valor inicial pode ser

– literal (inteiro, real, …, string),

– ponto de interrogação - valor inicial é indefinido

– count DUP(value,…) - multiplas ocorrências de um, ou mais, valores iniciais

empty db ? ; Byte com valor indefinido

integer dw 32000 ; Word inicializada a 32000

db 100 DUP(1) ; 100 Bytes inicializados a 1

msg1 db “Resultado=$”

No MS-DOS as cadeias terminam com $

(27)

Visibilidade

• Directivas para controlar a visibilidade de nomes entre

módulos de programas

– PUBLIC name,… – EXTRN name:type,…

Tipos possiveis:

• Variáveis externas: BYTE, WORD, DWORD, QWORD • Rotinas: FAR, NEAR

• Números absolutos: ABS

Exemplos

EXTRN _printf: FAR ; localização da rotina_printf

EXTRN var1: BYTE ; localização da variável de 1 BYTE var1

Operadores (1)

Operadores do Asm86 para cálculo de expressões:

1. LABEL: localização do topo da zona de memória declarada

imediatamente atrás

dw 4096 dup(?) _top LABEL WORD

_top LABEL WORD ;

mov ax, offset _top ; inicializar pilha

mov sp,ax ; //

2. OFFSET: deslocamento de variável ou etiqueta em relação ao

segmento

MOV EAX, OFFSET _hello LEA EAX, _hello

(28)

Operadores (2)

3. PTR: imposição de espaço

CALL FAR PTR subrot3

PUSH BYTE PTR [EBP]; carrega Byte endereçado por EBP

4. LENGTH: número de elementos de um array

5. SIZE: espaço ocupado (em Bytes)

array DW 100 DUP(1)

MOV EBX, LENGTH array ; EBX <- 100 MOV ECX,SIZE array ; ECX <- 200

Programa tipo (1)

Formato típico de um programa MASM

.model medium ;modelo DIM equ 40 ;constantes extrn _print:near ;visibilidade $pushr macro ;macros endm

_data segment word public 'DATA' ;declarações dados _data ends

(29)

Programa tipo (2)

_stack segment para stack 'STACK' stk dw 1024 dup(?)

_top label word _stack ends

_code segment word public 'CODE' _code segment word public 'CODE'

assume cs:_code,ds:_data,ss:_stack _start: ;programa _code ends end _start Assembly86 : 57/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Instruções (1)

• Instruções do IA-32 divididas em 9 classes

Classe Objectivos

Aritméticas

Conversão Conversão de dados Lógicas

Lógicas

Movimentação Deslocamento de informação de um local para outro Pilha Manipulação da pilha

Processador

Repetição Ciclos

Salto Alteração do registo IP

(30)

Instruções (2)

As seguintes abreviaturas são usadas:

Abreviatura Significado accum acumulador (EAX,AX ou AL)

reg registo Byte (AL,…), Word (AX,…) ou Dword (EAX…)

reg registo Byte (AL,…), Word (AX,…) ou Dword (EAX…) segreg registo segmento

r/m operando geral: registo, endereço de memória, operando indexado, operando baseado ou operando indexado baseado immed valor imediato (8 ou 16 bits)

mem operando de memória (etiqueta, variável ou símbolo) label etiqueta de instrução

Instruções (3)

A.Aritméticas

ADC accum,immed Add immediate with carry to accumulator ADC r/m,immed Add immediate with carry to operand ADC r/m,reg Add register with carry to operand ADC reg,r/m Add operand with carry to register ADC reg,r/m Add operand with carry to register ADD accum,immed Add immediate to accumulator ADD r/m,immed Add immediate to operand ADD r/m,reg Add register to operand ADD reg,r/m Add operand to reg DEC r/m Decrement operand DEC reg Decrement 16-bit register DIV r/m Divide accumulator by operand

IDIV r/m Integer divide accumulator by operand IMUL r/m Integer multiply accumulator by operand

(31)

Instruções (4)

INC r/m Increment operand INC reg Increment 16-bit register

MUL r/m Multiply accumulator by operand NEG r/m Negate operand

SBB accum,immed Subtract immediate with borrow SBB r/m,immed Subtract immediate with borrow SBB r/m,immed Subtract immediate with borrow SBB r/m,reg Subtract register with borrow SBB reg,r/m Subtract operand and carry flag SUB accum,immed Subtract immediate from accumulator SUB r/m,immed Subtract immediate from operand SUB r/m,reg Subtract register from operand SUB reg,r/m Subtract operand from register

Instruções (5)

B. Conversão

AAA ASCII adjust for addition AAD ASCII adjust for division AAM ASCII adjust for multiplication AAS ASCII adjust for subtraction AAS ASCII adjust for subtraction CBW Convert byte to word

CDQ Convert double word to quad word CWD Convert word to double word DAA Decimal adjust for addition DAS Decimal adjust for substraction

(32)

Instruções (6)

Exemplos

i. Multiplicação de inteiros

[DX:AX] <- AX * r/m

– O resultado de uma multiplicação de dois inteiros de 16 bits é – O resultado de uma multiplicação de dois inteiros de 16 bits é

um inteiro de 32 bits, residente no par DX:AX

– Normalmente, o multiplicador é colocado no registo DX

MOV AX,y ; carrega multiplicando MOV DX,5 ; carrega multiplicador IMUL DX ; DX:AX <- y*5

Instruções (7)

ii. Divisão de inteiros

AX <- [DX:AX] / r/m

– A instrução IDIV r/m exige um dividendo com 32 bits

– A conversão de um inteiro de 16 bits para inteiro de 32 bits é efectuada pela instrução CWD

efectuada pela instrução CWD

MOV AX,y ; carrega dividendo CWD

MOV BX,5 ; carrega divisor

(33)

Instruções (8)

C. Lógicas

AND accum,immed Bitwise And immediate with accumulator AND r/m,immed Bitwise And immediate with operand AND r/m,reg Bitwise And register with operand AND reg,r/m Bitwise And operand with register NOT r/m Invert operand bits

NOT r/m Invert operand bits

OR accum,immed Bitwise Or immediate with accumulator OR r/m,immed Bitwise Or immediate with operand OR r/m,reg Bitwise Or register with operand OR reg,r/m Bitwise Or operand with register RCL r/m,1 Rotate left through carry by 1 bit RCL r/m,CL Rotate left through carry by CL RCR r/m,1 Rotate right through carry by 1 bit RCR r/m,CL Rotate right through carry by CL

Instruções (9)

ROL r/m,1 Rotate left by 1 bit ROL r/m,CL Rotate left by CL ROR r/m,1 Rotate right by 1 bit ROR r/m,CL Rotate right by CL ROR r/m,CL Rotate right by CL

SAL r/m,1 Shift arithmetic left by 1 bit SAL r/m,CL Shift arithmetic left by CL SAR r/m,1 Shift arithmetic right by 1 bit SAR r/m,1 Shift arithmetic right by 1 bit SAR r/m,CL Shift arithmetic right by CL SHL r/m,1 Shift left by 1 bit

SHL r/m,CL Shift left by CL SHL r/m,1 Shift right by 1 bit SHL r/m,CL Shift right by CL

XOR accum,immed Bitwise Xor immediate with accumulator XOR r/m,immed Bitwise Xor immediate with operand XOR r/m,reg Bitwise Xor register with operand XOR reg,r/m Bitwise Xor operand with register

(34)

Instruções (10)

D. Movimentação de dados

IN accum,immed Input from port (8-bit immediate) IN accum,DX Input from port given by DX LAHF Load AH with flags

LDS r/m Load operand into DS

LEA r/m Load effective address of operand LES r/m Load operand into ES

LES r/m Load operand into ES LODS src Load string

LODSB Load byte from string into AL LODSW Load word from string into AH MOV accum,mem Move memory to accumulator MOV mem,accum Move accumulator to memory MOV r/m,immed Move immediate to operand MOV r/m,reg Move register to operand

MOV r/m,segreg Move segment register to operand MOV reg,immed Move immediate to register

Instruções (11)

MOV reg,r/m Move operand to register

MOV segreg, r/m Move operand to segment register MOVS dest,src Move string

MOVSB Move string byte by byte MOVSW Move string word by word bit OUT DX,accum Output to port given by DX OUT immed,accum Output to port (8-bit immediate OUT immed,accum Output to port (8-bit immediate SAHF Store AH into flags

STOS dest Store string

STOSB Store byte in AL at string STOSW Store word in AX at string

XCHG accum,reg Exchange accumulator with register XCHG r/m,reg Exchange operand with register XCHG r/reg,accum Exchange register with accumulator XCHG reg,r/m Exchange register with operand XLAT mem Translate

(35)

Instruções (12)

E. Pilha

CALL label Call instruction at label CALL r/m Call instruction indirect

INT3 Software interrupt 3 (encoded as one byte) INT immed Software Interrupt 0 through 255

INT immed Software Interrupt 0 through 255 INTO Interrupt on overflow

IRET Return from interrupt POP r/m Pop 16-bit operand

POP reg Pop 16-bit register from stack POP segreg Pop segment register

POPA Pop todos os registos POPF Pop flags

Instruções (13)

PUSH r/m Push 16-bit operand

PUSH reg Push 16-bit register onto stack PUSH segreg Push segment register

PUSHA Push all registers PUSHF Push flags

RET [immed] Return after popping bytes from stack

F.Processador

ESC immed,r/m Escape with 6-bit immediate and operand

HLT Halt

LOCK Lock bus NOP No operation

(36)

Instruções (14)

G.Repetição

LOOP label Loop

LOOPE label Loop while equal LOOPNE label Loop while not equal LOOPNZ label Loop while not zero LOOPNZ label Loop while not zero LOOPZ label Loop while zero REPE Repeat if equal REPNE Repeat if not equal REPNZ Repeat if not zero REPZ Repeat if zero SCAS dest Scan string

Instruções (15)

H.Salto

JA label Jump on above

JAE label Jump on above or equal JB label Jump on below

JBE label Jump on below or equal JC label Jump on carry

JC label Jump on carry

JCE label Jump on carry or equal JCXZ label Jump on CX zero JE label Jump on equal

JGE label Jump on greater or equal JL label Jump on less then

JLE label Jump on less then or equal JMP label Jump to instruction at label JMP r/m Jump to instruction indirect

(37)

Instruções (16)

JNA label Jump on not above

JNAE label Jump on not above or equal JNB label Jump on not below

JNBE label Jump on not below or equal JNC label Jump on not carry

JNE label Jump on not equal JNG label Jump on not greater JNG label Jump on not greater

JNGE label Jump on not greater or equal JNL label Jump on not less than

JNLE label Jump on not less than or equal JNO label Jump on not overflow

JP label Jump on parity JPE label Jump on parity even JPO label Jump on parity odd JS label Jump on sign JZ label Jump on zero

Instruções (17)

Teste

CLC Clear carry flag CLD Clear direction flag CLI Clear interrupt flag CMC Complement carry flag

CMP accum,immed Compare immediate with accumulator CMP r/m,immed Compare immediate with operand CMP r/m,reg Compare register with operand CMP r/m,reg Compare register with operand CMP reg,r/m Compare operand with register CMPS src,dest Compare strings

CMPSB Compare strings byte for byte CMPSW Compare strings word for word STC Set carry flag

STD Set direction flag STI Set interrupt flag

TEST accum,immed Compare immediate bits with accumulator TEST r/m,immed Compare immediate bits with operand TEST r/m,reg Compare register bits with operand TEST reg,r/m Compare operand bits with register

(38)

Transcrição: expressões (1)

• Para observar código gerado pelo gcc, usar opção -S

• As expressões no Asm86 seguem a representação

pós-fixada

1

_:

– Notação in-fixada: Z = X+Y – Notação pós-fixada Z = XY+ – Notação pós-fixada Z = XY+

Nota: no 8086, o operando X e o resultado Z residem num registos (ex: MOV AX,$var corresponde à operação AX=AX+$var)

1_{também designada por notação polaca invertida, em memória do seu}

proponente Jan Lukasiewicz (1878 - 1956)

Transcrição: expressões (2)

• Uma expressão em C é transcrita para Asm86 pela

sequência de instruções

1. Identificar a árvore de expressões, em profundidade 2. Para cada subexpressão E₁op E₂

1. Se operando E₁não estiver no registo, carregá-lo. 1. Se operando E₁não estiver no registo, carregá-lo.

2. Gerar instrução op E₁,E₂ (modo imediato, directo ou registo depende do operando E₂)

3. Resultado encontra-se disponível no registo E₁

Nota 1: selecção dos registos pode depender da operação. Se necessário deslocar conteúdo de registos.

Nota 2: registos devem ser seleccionados de forma criteriosa, para minimizar deslocamentos.

(39)

Transcrição: expressões (3)

Exemplos:

; x+5

MOV EAX,[$x]

ADD EAX,5 ; resultado colocado em [EAX] ; z*y

MOV EAX,[$z] MOV EAX,[$z] MOV EDX,[$y]

IMUL EDX ; resultado colocado em [EDX:EAX] ; 7*(x+1) // subexpressões: E₁=x+1 e E₂=7*E₁

MOV EAX,[$x]

INC EAX ; resultado colocado em [EAX] MOV EDX,7

IMUL EDX

• Um if em C é transcrito para Asm86 pela seguinte

sequência de instruções

1. Gerar instruções de cálculo da expressão de teste 2. Gerar comparação CMP

3. Inserir teste curto para ramo mais próximo (THEN)

Transcrição: execução condicional (1)

3. Inserir teste curto para ramo mais próximo (THEN) 4. Inserir salto para ramo mais afastado (ELSE)

5. No final do ramo mais próximo, inserir salto para depois do ramo mais afastado.

Nota

: Lembrar que na instrução de teste curto (J…), o

destino tem de estar a meio Byte de distância

(40)

Transcrição: execução condicional (2)

Exemplo:

; if((x+y)>=10)

MOV EAX,[$x]

ADD EAX,[$y] ; subexpressão colocada em [EAX] CMP EAX,10 JGE lbl_if JGE lbl_if JMP lbl_else lbl_if: ; bloco do IF JMP lbl_after lbl_else: ; bloco do ELSE lbl_after: Assembly86 : 79/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Transcrição: ciclo (1)

• Um while em C é transcrito para Asm86 pela

seguinte sequência de instruções

1. Gerar instruções de cálculo da expressão de teste. 2. Gerar comparação CMP.

3. Inserir teste curto para corpo (caso TRUE). 3. Inserir teste curto para corpo (caso TRUE). 4. Inserir salto para fora do corpo (caso FALSE).

5. No final do corpo, inserir salto para a primeira instrução de cálculo da expressão de teste.

(41)

Transcrição: ciclo (2)

Exemplo:

; while (x<100) lbl_cycle: MOV EAX,[$x] CMP EAX,100 JL lbl_block JL lbl_block JMP lbl_after lbl_block: ; bloco corpo JMP lbl_cycle lbl_after: Assembly86 : 81/87 Prof RG Crespo Criptografia e Segurança das Comunicações

Transcrição : rotinas (1)

• Rotinas chamadora e chamada usam pilha para guardar

parâmetros, endereço de retorno, e espaço de variáveis

locais.

• Valor de retorno pode ser armazenado num registo

(tipicamente EAX) ou na pilha.

Parâmetros

end. retorno

Rotina chamadora

Registos Variáveis locais

Rotina chamada

ESP

EBP

(42)

Transcrição : rotinas (2)

Passos na execução de rotinas

Rotina chamadora

1. Carregar parâmetros, pela instrução PUSH, da direita para a esquerda.

Nota: sentido direita→esquerda devido à existência de funções com número variável de parâmetros (ex: printf do C)

2. Chamar rotina pela instrução CALL (o processador insere 2. Chamar rotina pela instrução CALL (o processador insere

automaticamente na pilha o endereço de retorno).

Início da rotina chamada

1. Salvaguardar registos (pelo menos, EBP).

2. Copiar ESP para EBP (que passa a referenciar o registo de activação-“frame register”).

3. Subtrair a ESP espaço para as variáveis locais.

Nota: atenção ao alinhamento exigido (Intel pode ser ao Byte, SPARC exige ao duplo-32 bits).

Transcrição : rotinas (3)

– Variáveis locais acedidas na forma [EBP-desl]. – Parâmetros acedidos na forma [EBP+desl]:

se forem salvaguardados 4 registos num processador de 16 bits, o último parâmetro está deslocado de 4*2+2=10 Bytes.

Fim da rotina chamada Fim da rotina chamada

1. Instalar no EAX o valor de retorno.

2. Incrementar em ESP o espaço de variáveis locais.

3. Recuperar da pilha os registos, pela ordem inversa de salvaguarda. 4. Executar instrução RET nn (nn - espaço dos parâmetros).

(43)

Exemplo em MSDOS (1)

.model tiny

CR equ 0DH LF equ 0AH

_code segment word public 'CODE' org 0100H

assume cs:_code,ds:_code,ss:_code _start:

mov ax,_data ; initializes DS mov ds,ax ;

mov ax,_stack ; stack initialization mov ss,ax ;

mov dx, offset msg1; prints welcome message _close: mov al,00 ; terminates program

mov ah,04ch int 21h

Exemplo em MSDOS (1)

_data segment word public 'DATA'

Msg1 db "I am program 1",CR,LF,"$" _data ends

_stack segment para stack 'STACK' stk dw 1024

_top label word _stack ends

_stack ends

(44)

Sintaxe AT&T

• Nos programas C é possível inserir instruções Assembly

na forma

__asm__(″instrução″);

• Sintaxe usada nas instruções, designada AT&T, apresenta

5 diferenças em relação à sintaxe Intel.

1. Ordem dos operandos: destino,fonte (contrária à sintaxe Intel fonte,destino).

2. Registos prefixados com caractere % (ex: %ebp).

3. Operandos imediatos prefixados com caractere $ (ex: $0x8). 4. Dimensão dos operandos determinada por sufixo no código da

instrução b,w,l (ex: movb foo,%al). 5. Operandos de memória delimitados por ()