Criptografia e Segurança das Comunicações

Criptografia e Segurança das Comunicações Tópicos de Assembly86 Assembly86 : 1/87 Introdução (1) Curiosidade, não faz parte da avaliação 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 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. Produção de virus e ataques por buffer overflow Assembly86 : 2/87

Introdução (2) Curiosidade, não faz parte da avaliação Linguagem Alto Nível (HLL ex: C) Compilador Linguagem Assembly (ex: Asm86) Linguagem máquina Interpretação processsor Especificação controlo sinais Assembler v[i] = 2; LEA BX,$v MOV DX,$i MOV AX,2 MOV [BX+DX],AX MEEC:Programação MEEC: Criptografia e Segurança das Comunicações 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 Assembly86 : 3/87 Introdução (3) Curiosidade, não faz parte da avaliação 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 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. Assembly86 : 4/87

Lista processadores Intel (1) Curiosidade, não faz parte da avaliação 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. 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. Assembly86 : 5/87 Lista processadores Intel (2) Curiosidade, não faz parte da avaliação 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. 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 http://developer.intel.com/products/processor/manuals Assembly86 : 6/87

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. Assembly86 : 7/87 Pentium arquitectura (2) Curiosidade, não faz parte da avaliação 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, 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 registos. Assembly86 : 8/87

Pentium arquitectura (3) Distribuição das componentes de um programa no Pentium EBP SP Pilha( stack ) Registos uso geral Registos segmento SS DS EIP CS Arena( heap ) Dados estáticos Código EAX EBX ECX EDX EDI ESI Assembly86 : 9/87 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 ). 8 de multimédia. Assembly86 : 10/87

Registos: uso geral (1) IA-32: Os registos de uso geral podem ser acedidos individualmente na parte inferior Deslocamentos de blocos de memória{ 16-bit 32-bit AH AL AX EAX BH BL BX EBX CH CL CX ECX DH DL DX EDX BP EBP SI ESI DI EDI SP ESP Assembly86 : 11/87 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). Assembly86 : 12/87

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) 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). Assembly86 : 13/87 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 Sentido do PUSH EBP ESP End. retorno Registos Variáveis locais Posições livres Espaço obtido por subtracção de ESP Assembly86 : 14/87

Registos: uso geral (5) Curiosidade, não faz parte da avaliação 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 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). Assembly86 : 15/87 Registos: uso geral (6) Curiosidade, não faz parte da avaliação 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, DI,SI, DI,SI, BP,SP 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 Assembly86 : 16/87

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) 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). Assembly86 : 17/87 Registos: bandeiras (2) Nome CF PF AF ZF SF TF IF DF OF Função Carry flag. Colocado a 1 se houver transporte ou empréstimo. Parity flag. Colocado a 1 se os 8 bits inferiores tiverem número par de 1's. Auxiliary carry flag. Colocado a 1 se houver transporte ou empréstimo dos 4 bits inferiores de AL Zero flag. Colocado a 1 se o resultado for nulo Sign flag. Igual ao bit mais significativo Trap flag. Interrupt flag. Direction flag. Overflow flag. Colocado a 1 se o resultado não puder ser expresso dentro do numero de bits do destino. Assembly86 : 18/87

Registos: vírgula flutuante Curiosidade, não faz parte da avaliação O Pentium possui o conjunto ST de 8 registos de 80 bits, para vírgula flutuante ST manipulado como pilha Carregamento feito pela instruçãofst val em vez de MOV reg,val AdiçãoFADD 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 Assembly86 : 19/87 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. Assembly86 : 20/87

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 Ex: CS=01200h, IP=03f7h Endereço efectivo = 021000h+03f7h = 0123f7h Segmento offset EA 64KB 00000h Assembly86 : 21/87 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) Pentium possui dois registos extra de segmento: FS e GS Assembly86 : 22/87

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 [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 Assembly86 : 23/87 Modos de operação (6) Curiosidade, não faz parte da avaliação 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 32bits Limite superior Descritores Descritores Segmento 13 bits Limite superior Endereço base 32bits EA LDT- Local Descriptor Table, uma por processo GDT- Global Descriptor Table, uma para o sistema operativo Assembly86 : 24/87

Modos de operação (7) Curiosidade, não faz parte da avaliação 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 Assembly86 : 25/87 Modos de operação (8) Curiosidade, não faz parte da avaliação 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 2 32 = 4GB. 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. Endereço Endereçamento Linear (virtual) Assembly86 : 26/87

Modos de operação (9) Curiosidade, não faz parte da avaliação O endereço virtual é depois transcrito, pelo µp, para endereço físico por paginação. Assembly86 : 27/87 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 POP EAX ; 16 bits ; 32 bits Assembly86 : 28/87

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 PUSH Byte PTR 0 ; 32 bits ; 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) Assembly86 : 29/87 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] PUSH Byte PTR [$m+edx+ebp] Insere na pilha Word de uma tabela $m no índice indicado em EAX*2 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 DS. Assembly86 : 30/87

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. 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. Assembly86 : 31/87 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) Assembly86 : 32/87

Formato de instruções Curiosidade, não faz parte da avaliação As instruções variam entre 1 e 17 B Prefixo Opcode Mode SIB disp-low disp-high Operação Scale Destino Mod Reg r/m Index Operando Byte/Word Base 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 Assembly86 : 33/87 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. 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. Um operando pode vir da memória. Ex: MOV AX,$var carrega para AX o conteúdo da variável $var. Assembly86 : 34/87

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 Assembly86 : 35/87 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) 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 Flat: Um único segmento até 4GB. Assembly86 : 36/87

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) Assembly86 : 37/87 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 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 Assembly86 : 38/87

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 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. Assembly86 : 39/87 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' 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 Assembly86 : 40/87

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 Cancela selecção existente Exemplo: ASSUME CS:_code, DS:_code, SS:_code Todos os segmentos dentro do mesmo segmento lógico Assembly86 : 41/87 Directivas (3) Proc, Endp Delimitam rotinas name PROC type name ENDP O tipo da rotina pode ser NEAR (rotina chamada dentro do segmento) oufar. O nome da rotina pode ser usado como operando de instruções jump, call ouloop. No corpo da rotina deve existir pelo menos uma instruçãoret. Assembly86 : 42/87

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 _main PROC NEAR ; ; programa e dados ; _code ENDS ; ponto entrada do programa END _main Assembly86 : 43/87 Directivas (5) Equ Constante na forma name EQU valor CR EQU 0dh LF EQU 0ah DIM EQU 100 _newline DB CR,LF, $ _data DB DIM DUP(0) Assembly86 : 44/87

Macros (1) [Def] Uma macro é uma inserção inline de código, delimitado pormacro endm $pushr MACRO push push push push ENDM $pushr bp bx cx dx ; salvaguarda registos na pilha Parâmetros podem ser usados $writes MACRO p1 mov dx, offset p1 mov ah,09h int 21h ENDM Assembly86 : 45/87 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 jl failure $writes POS jmp out failure $writes NEG out ENDM Assembly86 : 46/87

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, 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' ) Assembly86 : 47/87 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. Para uma tabela/estrutura, a distribuição em memória é bigendien. 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) Conversão imediata de inteiros 16-bit para 32-bit. Assembly86 : 48/87

Inteiros, Cadeias caracteres (3) Exemplos: 1. Representar o endereço 12345678 Endereço 00 01 10 11 Big Endian 12 34 56 78 Little Endian 78 56 34 12 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 Assembly86 : 49/87 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 Letras minúsculas convertidas para maiúsculas. Apenas são considerados os primeiros 31 caracteres. Assembly86 : 50/87

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 Assembly86 : 51/87 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 $ Assembly86 : 52/87

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 Assembly86 : 53/87 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 _top dw 4096 dup(?) 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 LEA EAX, OFFSET _hello EAX, _hello Assembly86 : 54/87

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 Assembly86 : 55/87 Programa tipo (1) Formato típico de um programa MASM.model medium ;modelo DIM equ 40 ;constantes extrn _print:near ;visibilidade $pushr macro endm ;macros _data segment word public 'DATA' _data ends ;declarações dados Assembly86 : 56/87

Programa tipo (2) _stack segment para stack 'STACK' stk dw 1024 dup(?) _top label word _stack ends _code segment word public 'CODE' assume cs:_code,ds:_data,ss:_stack _start: ; programa _code ends end _start Assembly86 : 57/87 Instruções (1) Instruções do IA-32 divididas em 9 classes Classe Aritméticas Objectivos Conversão Conversão de dados Lógicas Movimentação Pilha Deslocamento de informação de um local para outro Manipulação da pilha Processador Repetição Salto Teste Ciclos Alteração do registo IP Modificação do registo de bandeiras Assembly86 : 58/87

Instruções (2) As seguintes abreviaturas são usadas: Abreviatura accum reg segreg r/m immed mem label acumulador (EAX,AX ou AL) Significado registo Byte (AL, ), Word (AX, ) ou Dword (EAX ) registo segmento operando geral: registo, endereço de memória, operando indexado, operando baseado ou operando indexado baseado valor imediato (8 ou 16 bits) operando de memória (etiqueta, variável ou símbolo) etiqueta de instrução Assembly86 : 59/87 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 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 Assembly86 : 60/87

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,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 Assembly86 : 61/87 Instruções (5) B. Conversão AAA AAD AAM AAS CBW CDQ CWD DAA DAS ASCII adjust for addition ASCII adjust for division ASCII adjust for multiplication ASCII adjust for subtraction Convert byte to word Convert double word to quad word Convert word to double word Decimal adjust for addition Decimal adjust for substraction Assembly86 : 62/87

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 é 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 Assembly86 : 63/87 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 MOV AX,y ; carrega dividendo CWD MOV BX,5 ; carrega divisor IDIV BX ; AX <- y/5, DX <- resto divisão Assembly86 : 64/87

Instruções (8) C. Lógicas AND accum,immed AND r/m,immed AND r/m,reg AND reg,r/m NOT r/m OR accum,immed OR r/m,immed OR r/m,reg OR reg,r/m RCL r/m,1 RCL r/m,cl RCR r/m,1 RCR r/m,cl Bitwise And immediate with accumulator Bitwise And immediate with operand Bitwise And register with operand Bitwise And operand with register Invert operand bits Bitwise Or immediate with accumulator Bitwise Or immediate with operand Bitwise Or register with operand Bitwise Or operand with register Rotate left through carry by 1 bit Rotate left through carry by CL Rotate right through carry by 1 bit Rotate right through carry by CL Assembly86 : 65/87 Instruções (9) ROL r/m,1 ROL r/m,cl ROR r/m,1 ROR r/m,cl ROR r/m,cl SAL r/m,1 SAL r/m,cl SAR r/m,1 SAR r/m,cl SHL r/m,1 SHL r/m,cl SHL r/m,1 SHL r/m,cl XOR accum,immed XOR r/m,immed XOR r/m,reg XOR reg,r/m Rotate left by 1 bit Rotate left by CL Rotate right by 1 bit Rotate right by CL Rotate right by CL Shift arithmetic left by 1 bit Shift arithmetic left by CL Shift arithmetic right by 1 bit Shift arithmetic right by CL Shift left by 1 bit Shift left by CL Shift right by 1 bit Shift right by CL Bitwise Xor immediate with accumulator Bitwise Xor immediate with operand Bitwise Xor register with operand Bitwise Xor operand with register Assembly86 : 66/87

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 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 Assembly86 : 67/87 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 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 Assembly86 : 68/87

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 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 Assembly86 : 69/87 Instruções (13) PUSH r/m PUSH reg PUSH segreg PUSHA PUSHF RET [immed] Push 16-bit operand Push 16-bit register onto stack Push segment register Push all registers Push flags Return after popping bytes from stack F.Processador ESC immed,r/m HLT LOCK NOP WAIT Escape with 6-bit immediate and operand Halt Lock bus No operation Wait Assembly86 : 70/87

Instruções (14) G.Repetição LOOP label LOOPE label LOOPNE label LOOPNZ label LOOPZ label REPE REPNE REPNZ REPZ SCAS dest Loop Loop while equal Loop while not equal Loop while not zero Loop while zero Repeat if equal Repeat if not equal Repeat if not zero Repeat if zero Scan string Assembly86 : 71/87 Instruções (15) H.Salto JA label JAE label JB label JBE label JC label JCE label JCXZ label JE label JGE label JL label JLE label JMP label JMP r/m Jump on above Jump on above or equal Jump on below Jump on below or equal Jump on carry Jump on carry or equal Jump on CX zero Jump on equal Jump on greater or equal Jump on less then Jump on less then or equal Jump to instruction at label Jump to instruction indirect Assembly86 : 72/87

Instruções (16) JNA label JNAE label JNB label JNBE label JNC label JNE label JNG label JNGE label JNL label JNLE label JNO label JP label JPE label JPO label JS label JZ label Jump on not above Jump on not above or equal Jump on not below Jump on not below or equal Jump on not carry Jump on not equal Jump on not greater Jump on not greater or equal Jump on not less than Jump on not less than or equal Jump on not overflow Jump on parity Jump on parity even Jump on parity odd Jump on sign Jump on zero Assembly86 : 73/87 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 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 Assembly86 : 74/87

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ósfixada 1 : Notação in-fixada: Z = X+Y 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) Assembly86 : 75/87 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 1 op E 2 1. Se operando E 1 não estiver no registo, carregá-lo. 2. Gerar instrução op E 1,E 2 (modo imediato, directo ou registo depende do operando E 2 ) 3. Resultado encontra-se disponível no registo E 1 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. Assembly86 : 76/87

Transcrição: expressões (3) Exemplos: ; x+5 MOV EAX,[$x] ADD EAX,5 ; resultado colocado em [EAX] ; z*y MOV EAX,[$z] MOV EDX,[$y] IMUL EDX ; resultado colocado em [EDX:EAX] ; 7*(x+1) // subexpressões: E 1 =x+1 e E 2 =7*E 1 MOV EAX,[$x] INC EAX ; resultado colocado em [EAX] MOV EDX,7 IMUL EDX Assembly86 : 77/87 Transcrição: execução condicional (1) 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) 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 Assembly86 : 78/87

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 JMP lbl_else lbl_if: ; bloco do IF JMP lbl_after lbl_else: ; bloco do ELSE lbl_after: Assembly86 : 79/87 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). 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. Assembly86 : 80/87

Transcrição: ciclo (2) Exemplo: ; while (x<100) lbl_cycle: MOV EAX,[$x] CMP EAX,100 JL lbl_block JMP lbl_after lbl_block: ; bloco corpo JMP lbl_cycle lbl_after: Assembly86 : 81/87 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. EBP Parâmetros end. retorno Registos Variáveis Rotina chamadora Rotina chamada ESP locais Assembly86 : 82/87

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 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). Assembly86 : 83/87 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 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çãoret nn (nn - espaço dos parâmetros). Assembly86 : 84/87

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 Assembly86 : 85/87 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 end _start Assembly86 : 86/87

Sintaxe AT&T Curiosidade, não faz parte da avaliação 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 () Assembly86 : 87/87