Prévia do material em texto
1
GABARITO AD1 – 2025/1
Na organização de computadores, certas decisões de projeto podem introduzir
vulnerabilidades, que podem ser exploradas por atacantes ou causar falhas inesperadas
nos sistemas. Nesta lista de exercícios, exploramos essa relação por meio de problemas
que se relacionam com vulnerabilidades conhecidas, categorizadas pelo Common
Weakness Enumeration (CWE) — uma base de dados mantida pela comunidade de
segurança para classificar tipos comuns de fraquezas em software e hardware:
https://cwe.mitre.org/
1. (2,0 pontos) Nesta questão, vamos explorar o conceito de verificação de limites.
a) (1,5 pontos) Considere as seguintes fórmulas
Y = min( [20] + [21], [18] )
Z = max( Y, [19] )
Em um computador que utiliza a linguagem de montagem apresentada na tabela
a seguir, há dois valores armazenados na memória, nos endereços 20 e 21. Os
valores podem ser negativos ou positivos. Faça um programa que realize os
seguintes procedimentos:
1. Some os dois valores armazenados na memória e armazene o resultado no
endereço 22.
2. Se o resultado da soma ultrapassar o valor armazenado no endereço 18,
armazene o valor contido no endereço 18 no endereço 22.
3. Se o resultado da soma for menor que o valor armazenado no endereço 19,
armazene o valor contido no endereço 19 no endereço 22.
4. Caso contrário, armazene o valor normalmente.
Caso especial ilustrativo: Note que se o valor contido na posição 18 for 7 e o valor
contido na posição 19 for 0, o valor resultante sempre caberá em 4 bits. Tarefas
críticas podem utilizar exclusivamente esses 4 bits para a tomada de decisões, daí
a importância do programa acima: garantir que o resultado esteja dentro desse limite
é essencial para o funcionamento correto do sistema.
Endereço
(hexa) Instrução Descrição Linguagem Máquina (bin / hexa)
18 Dado
19 Dado
...
20 Dado 1º valor
21 Dado 2º valor
22 Dado Resultado
.....
Item 1: Some os dois valores armazenados na memória e armazene o resultado no endereço 22.
30 LDA 20 ACC ← (20) ( 0001 0010 0000 / 120 )
31 ADD 21 ACC ← ACC + (21) ( 0011 0010 0001 / 321 )
2
32 STR 22 (22) ← ACC ( 0010 0010 0010 / 222 )
Item 2: Se o resultado da soma ultrapassar o valor armazenado no endereço 18, armazene o
valor contido no endereço 18 no endereço 22..
33 LDA 22 ACC ← (22) ( 0001 0010 0010 / 122 )
34 SUB 18 ACC ← ACC - (18) ( 0100 0001 1000 / 418 )
35 JP 37 se ACC > 0, CI ← 37 ( 0110 0011 0111 / 637 )
36 JMP 39 CI ← 39 ( 1000 0011 1001 / 839 )
37 LDA 18 ACC ← (18) ( 0001 0001 1000 / 118 )
38 STR 22 (22) ← ACC ( 0010 0010 0010 / 222 )
Item 3: Se o resultado da soma for menor que o valor armazenado no endereço 19, armazene
o valor contido no endereço 19 no endereço 22.
Item 4: Caso contrário, armazene o valor normalmente.
39 LDA 19 ACC ← (19) ( 0001 0001 1001 / 119 )
3A SUB 22 ACC ← ACC - (22) ( 0100 0010 0010 / 422 )
3B JP 3D se ACC > 0, CI ← 3D ( 0110 0011 1101 / 63D )
3C JMP 3F CI ← 3F ( 1000 0011 1111 / 83F )
3D LDA 19 ACC ← (19) ( 0001 0001 1001 / 119 )
3E STR 22 (22) ← ACC ( 0010 0010 0010 / 222 )
3F HALT HALT ( 0000 0000 0000 / 000 )
Caso geral: No caso geral, o programa deve garantir que o resultado esteja dentro
do intervalo que inicia com o valor contido na posição 19 e termina com o valor
contido na posição 18. O caso especial acima ilustra a importância desse controle
para restrições de bits.
Nos itens a seguir, considere o caso geral.
Além de apresentar seu programa em linguagem de montagem, apresente também
o programa traduzido para linguagem de máquina.
OBS: Alguns projetistas de processadores especificam que, nas instruções em
assembly, a referência ao conteúdo de uma célula é representada por parênteses
— por exemplo, ACC MAX_DIM || n > MAX_DIM) {
die("Dimensão muito grande!");
}
board = (board_square_t*)malloc(m * n * sizeof(board_square_t));
CWE-190: Integer Overflow or Wraparound
https://cwe.mitre.org/data/definitions/190.html
→ Se o programa não tratar corretamente limites, poderá levar a um
comportamento inesperado do sistema.
A ausência de verificação de limites pode resultar em falhas críticas nos programas, como
estouros de buffer, corrupção de memória e vulnerabilidades de segurança.
Por exemplo, no caso do CWE-190 (Integer Overflow or Wraparound), considere o trecho de
código em C logo abaixo. Se num_imgs for um valor suficientemente grande, a multiplicação
sizeof(img_t) * num_imgs pode causar um overflow inteiro, resultando na alocação de um
buffer menor do que o necessário. Operações subsequentes que assumem o tamanho correto do
buffer podem levar a acessos fora dos limites, causando corrupção de memória ou execução de
código arbitrário
4
int num_imgs;
img_t *table_ptr;
...
num_imgs = get_num_imgs();
table_ptr = (img_t*)malloc(sizeof(img_t) * num_imgs);
Cod.
Oper.
Sigla Significado Descrição
0 HLT halt (pare) Parar a execução do programa
1 LDA Op.
load accumulator
(carregar da memória
para acumulador)
ACC ← (Op.), Load
2 STR Op.
store accumulator
(armazenar acumulador
na memória)
(Op.) ← ACC, Store
3 ADD Op. add (some) ACC ← ACC + (Op.)
4 SUB Op. subtract (subtraia) ACC ← ACC - (Op.)
5 JZ Op. jump zero (pule se zero) Se ACC = 0, então CI ← (Op.)
6 JP Op.
jump positive (pule se
acumulador positivo)
Se ACC > 0, então CI ← (Op.)
7 JN Op.
jump negative (pule se
acumulador negativo)
Se ACC← (Op.)
9 DIV Op. divide (divida) ACC ← ACC / (Op.)
A ABS Op.
absolute value (valor
absoluto)
ACC ← |(Op.)|
2. (2,0 pontos) Nesta questão, vamos explorar o vazamento de informações
sensíveis via tempo de resposta. Assuma, para fins didáticos, que o tempo para
executar cada instrução é perceptível e mensurável.
Em um computador que utiliza a linguagem de montagem apresentada na tabela acima,
há uma senha armazenada nos endereços 20, 21, 22 e 23, contendo os valores 1, 2, 3 e
4, respectivamente (ou seja, a senha é 1234). O programa a seguir verifica se uma
entrada corresponde à senha correta, comparando os valores digitados pelo usuário, que
são armazenados nos endereços 30, 31, 32 e 33.
O código abaixo executa essa verificação:
LDA 30 ; Carrega o primeiro número digitado
SUB 20 ; Compara com o primeiro número da senha
JZ CHECK_2 ; Se for igual, verifica o segundo número
JMP FAIL ; Caso contrário, senha errada
5
CHECK_2:
LDA 31
SUB 21
JZ CHECK_3
JMP FAIL
CHECK_3:
LDA 32
SUB 22
JZ CHECK_4
JMP FAIL
CHECK_4:
LDA 33
SUB 23
JZ SUCCESS
JMP FAIL
FAIL:
HLT ; Senha incorreta
SUCCESS:
HLT ; Senha correta
O tipo de ataque considerado nesta questão é conhecido como "time-based side-
channel attack" e está classificado na base CWE sob a referência:
CWE-208: Observable Timing Discrepancy
https://cwe.mitre.org/data/definitions/208.html
→ Um atacante pode inferir informações sensíveis analisando variações no
tempo de resposta, levando a vazamento de dados.
a) (0,5 ponto) Explique como funciona o programa e por que esse programa
permite que um atacante descubra, por exemplo, o primeiro dígito da senha,
medindo o tempo de resposta
O programa verifica se a entrada do usuário corresponde à senha correta comparando
os valores digitados um por um. Se um dígito estiver incorreto, o programa interrompe a
execução imediatamente, enquanto, se estiver correto, a verificação continua para o próximo
dígito.
Essa lógica cria uma diferença no tempo de execução, pois um erro nos primeiros
dígitos resulta em uma interrupção mais rápida, enquanto um erro posterior leva a um tempo
de execução maior.
Um atacante pode explorar essa discrepância medindo o tempo de resposta de diversas
tentativas. Ao testar diferentes valores no primeiro dígito e observar se a execução dura mais
tempo, ele pode determinar quando acertou e repetir o processo para os outros dígitos,
reconstruindo a senha completa.
6
b) (0,5 ponto) Sugira, em linhas gerais, uma modificação no programa para impedir
que um atacante use essa técnica. Você não precisa implementar a modificação.
Para evitar essa exploração baseada no tempo de resposta, é necessário garantir que
o programa leve o mesmo tempo de execução independentemente da entrada. Isso pode ser feito
realizando todas as comparações antes de tomar uma decisão final, usando uma variável
auxiliar para armazenar um indicador de erro em vez de interromper a execução imediatamente
ou inserindo atrasos artificiais para uniformizar o tempo de resposta
c) (0,5 ponto) Assuma que a senha não esteja armazenada inicialmente em cache,
mas que as posições de memória vão sendo colocadas em cache na medida em
que vão sendo requisitadas. Apenas os valores que foram acessados
recentemente permanecem no cache. Como um atacante poderia, ao fazer um
ataque de força bruta, usar o tempo de resposta e a localidade temporal para
determinar qual o último byte verificado com sucesso?
Um atacante pode explorar a localidade temporal do cache para identificar qual foi o
último byte verificado com sucesso. Como a senha não está inicialmente no cache, mas vai sendo
armazenada conforme os bytes são acessados, o invasor pode testar senhas diferentes e, após a
falha, medir o tempo de acesso a cada posição de memória. A posição que for acessada mais
rapidamente provavelmente contém o último byte verificado com sucesso, pois ele ainda estará
no cache. Repetindo esse processo, o atacante pode reconstruir a senha explorando o tempo de
resposta e o comportamento do cache.
d) (0,5 ponto) Qual seria uma estratégia para mitigar esse tipo de ataque explorando
o cache?
Para mitigar esse tipo de ataque, é importante garantir que todas as posições de
memória da senha sejam acessadas sempre, independentemente do sucesso ou falha da
verificação. Isso pode ser feito acessando forçadamente todas as posições de memória da senha
após cada verificação, utilizando técnicas de prefetching para carregar toda a senha na cache
antes de iniciar a verificação e implementando comparações que percorrem todos os bytes da
senha antes de tomar uma decisão final. Com essas técnicas, o atacante não conseguiria
distinguir qual foi o último byte verificado com sucesso apenas pela análise do tempo de
resposta ou do comportamento do cache
3. (2,0 pontos) Nessa questão, vamos considerar mais uma vez a hierarquia de
memória. Em particular, vamos focar na seguinte classe de vulnerabilidades:
CWE-385: Covert Timing Channel
https://cwe.mitre.org/data/definitions/385.html
→ Se um atacante puder inferir informações sensíveis medindo tempos de
acesso à memória, isso pode levar a um vazamento indireto de dados,
explorando um canal lateral de tempo.
a) (0,5 ponto) Descreva a hierarquia de memória abordada no curso e posicione os
elementos relativos ao acesso de dados de um arquivo nessa hierarquia.
A hierarquia de memória abordada no curso consiste em diferentes níveis de armazenamento,
organizados de acordo com tempo de acesso, capacidade e custo. Os níveis mais rápidos e
menores estão no topo da hierarquia, enquanto os mais lentos e maiores estão na base. A
hierarquia segue a seguinte estrutura:
Registradores: Localizados na CPU, são os mais rápidos e acessíveis diretamente pelas
instruções do processador.
7
Cache (L1, L2, L3): Pequenas memórias próximas à CPU que armazenam dados
recentemente acessados para reduzir latência.
Memória RAM (Memória Principal): Armazena dados temporários e programas em
execução. É mais lenta que o cache, mas possui maior capacidade.
Armazenamento Secundário (SSD/HDD): Dispositivos permanentes para armazenar
dados de longo prazo. SSDs são mais rápidos que HDDs
b) (1,0 ponto) Considere um cenário em que um atacante compartilha um sistema
com outro usuário, como um servidor, e o atacante quer descobrir se um
arquivo específico foi acessado recentemente.
Exemplo: Um usuário legítimo acessa um documento sigiloso chamado
investigacao_secreta.pdf, contendo informações sobre um caso de corrupção.
Um espião suspeita que o arquivo foi acessado pelo usuário, e deseja descobrir
quando esse arquivo foi acessado pela última vez, mesmo sem ter permissão para
lê-lo diretamente.
Temos os seguintes passos:
i) O espião esvazia o cache usando instruções como clflush em
arquiteturas x86 ou acessos controlados a dados em outros sistemas.
ii) O usuário legítimo acessa um arquivo importante. Como esse arquivo
pode navegar dentro da hierarquia de memória?
Se o arquivo foi acessado, ele pode ser carregado do armazenamento
secundário para a RAM e possivelmente para o cache, dependendo da frequência de
acesso e do gerenciamento da memória pelo sistema operacional
iii) O espião mede o tempo de acesso ao arquivo: Se o tempo for curto ou
longo, o que isso significa?
O espião tenta acessar o mesmo arquivo (ou dados relacionados, como
metadados). Se o acesso for rápido, significa que o arquivo já está na cache ou na
RAM, indicando que foi acessado recentemente. Se o acesso for lento, significa que o
arquivo não estava na cache e precisou ser carregado do armazenamento secundário,
sugerindo que não foi acessado há algum tempo.
c) (0,5 ponto) Como mitigar o ataque em questão?
Para mitigar esse ataque, o sistema pode adotar diversas estratégias. A introdução de
atrasos artificiais no carregamento de arquivospode mascarar as diferenças de tempo de
acesso. A remoção forçada de dados sigilosos da cache imediatamente após o uso impede que
acessos futuros revelem informações anteriores. Além disso, técnicas de prefetching e flushing
podem ser empregadas para tornar os tempos de acesso mais imprevisíveis. O monitoramento
de padrões suspeitos de acesso, como tentativas repetidas de medir tempos de resposta, pode
ajudar a detectar possíveis ataques. Outra abordagem é a criptografia e ocultação de
metadados, dificultando que um atacante obtenha pistas sobre quando um arquivo foi utilizado.
Com essas medidas, a exploração de canais laterais baseados em tempo se torna muito mais
difícil, reduzindo o risco de vazamento de informações sensíveis
4. (2,0 pontos) O tempo de execução de um programa pode revelar informações
sensíveis sobre o funcionamento do sistema, permitindo que um atacante explore
diferenças no tempo de processamento para inferir quais operações estão sendo
8
executadas e até mesmo identificar padrões de execução de instruções. A identificação
de propriedades do sistema é um passo importante em qualquer tipo de ataque.
Considere um atacante que deseje descobrir a frequência de clock com que uma máquina
está executando seus programas, e deseje também saber se ela está processando
comandos sequencialmente ou usando pipeline. Para tal, ele executa vários programas,
na máquina cujos atributos ele quer estimar.
O atacante pode fazer isso da seguinte forma:
a) Medição do clock
○ Ele executa um programa curto com N=10 instruções e mede o tempo
total de execução, igual a 5 nanossegundos.
○ Como o número de ciclos necessários para cada instrução na máquina
alvo é conhecido, igual a 6, ele pode estimar a frequência do clock com
base no tempo total de execução.
Qual a frequência de clock do relógio?
Considerando execução sequencial.
A frequência será = total de ciclos / tempo de execução
= 10 instruções x 6 ciclos/instrução / 5ns
= 60/5 = 12ciclos/ns => clock = 12 ciclos / 0,000000001 = 12GHz
b) Detecção de execução sequencial
○ Ele compara a execução de um programa curto com um programa longo.
○ Se o tempo de execução aumentar linearmente com o número de
instruções, a CPU está executando sequencialmente.
Qual o tempo de execução do programa longo, se o programa longo contiver kN
instruções, assumindo que a CPU esteja executando sequencialmente? Faça uma
tabela, variando k de 1 a 10.
k Tempo para N=10 instruções
Tempo total sequencial para
kN instruções
1 5ns 5ns
2 5ns 10ns
3 5ns 15ns
4 5ns 20ns
5 5ns 25ns
6 5ns 30ns
7 5ns 35ns
8 5ns 40ns
9 5ns 45ns
10 5ns 50ns
c) Detecção de execução pipeline
○ Se o tempo de execução variar de forma diferente daquela considerada
no item acima, a CPU pode estar usando pipeline para processar
múltiplas instruções simultaneamente.
Assuma que o pipeline é de E estágios, todos de duração igual a 1 ciclo
de relógio. A execução de cada instrução corresponde a E estágios. Assuma
9
que, quando a máquina utiliza pipeline, é necessário executar X instruções
extras, de inicialização do pipeline, e que cada uma dessas instruções tem
duração de 1 estágio. Assuma também que essas instruções são executadas de
forma sequencial, ou seja, cada instrução de inicialização é executada em 1
ciclo de relógio e a execução de uma instrução de inicialização só se inicia
quando a execução da instrução anterior é finalizada. Calcule o tempo para
executar o programa curto com N=10 instruções, assumindo que temos E=5,
X=4 e a frequência F é igual a aquela calculada no item a. Em seguida, calcule
o tempo para executar o programa longo com kN instruções. Compare sua
resposta para este item com a sua resposta para o item anterior, para k variando
entre 1 e 10, e indique como que o atacante será capaz de identificar se a
máquina está rodando o sistema com ou sem pipeline.
Testágio = 1 ciclo clock = 1/12GHz = 0,0833ns
Tpipeline = Textra + Tprimeira + Tdemais
Textra = X = 4 instruções extras x 0,0833ns
= 4 x 0,0833 = 0,333ns
Tprimeira = E=5 estágios x Testágio = 5 x 0,0833 = 0,4165ns
Tdemais = (kN – 1) x Testágio = (kN – 1) x 0,0833 ns
k Textra Tprimeira Tdemais
Tempo total
pipeline para kN
instruções ( ns)
Tempo total
sequencial para
kN instruções
1 0,333ns 0,4165ns 0,7497 1,50 5ns
2 0,333ns 0,4165ns 1,5827 2,33 10ns
3 0,333ns 0,4165ns 2,4157 3,17 15ns
4 0,333ns 0,4165ns 3,2487 4,00 20ns
5 0,333ns 0,4165ns 4,0817 4,83 25ns
6 0,333ns 0,4165ns 4,9147 5,66 30ns
7 0,333ns 0,4165ns 5,7477 6,50 35ns
8 0,333ns 0,4165ns 6,5807 7,33 40ns
9 0,333ns 0,4165ns 7,4137 8,16 45ns
10 0,333ns 0,4165ns 8,2467 9,00 50ns
A tabela gerada mostra a comparação entre os tempos de execução com e sem pipeline para
diferentes valores de kkk. Observando os dados, fica evidente que o tempo de execução com
pipeline cresce mais lentamente do que no caso sem pipeline.
O atacante pode identificar se a máquina está utilizando pipeline observando a relação entre o
tempo de execução e o número de instruções. Se o tempo aumentar de forma linear e
proporcional ao número de instruções (como no caso sem pipeline), significa que as instruções
estão sendo executadas sequencialmente. No entanto, se o tempo crescer mais lentamente, isso
indica que a CPU está utilizando pipeline para processar múltiplas instruções simultaneamente,
reduzindo a latência por instrução após a fase inicial de inicialização do pipeline
5. (2,0 pontos) Considere um projetista que deseja projetar uma CPU e uma memória,
de forma combinada, sendo que a memória possui C células, cada célula armazenando
uma palavra. Cada palavra possui P bytes, e cada palavra deve armazenar instruções
com as seguintes propriedades:
1) existem I instruções no conjunto de instruções
2) cada instrução suporta O operando, sendo que cada operando é um endereço de
uma célula de memória
10
Responda:
a) (1,0 ponto) Preencha a seguinte tabela, e indique, em cada caso, o tamanho
mínimo do RDM, REM e RI:
Observação: se a memória tem 256 mega células, isso quer dizer que ela possui 256 *
2^20 células, ou seja, 268435456 células.
b) (1,0 ponto) considerando CWE-125 e CWE-787. Riscos de segurança no
endereçamento de memória, considerando CWE-125 e CWE-787. Explique
como um projetista pode garantir que os acessos à memória sejam protegidos
contra ataques de leitura/escrita fora dos limites.
i) Como evitar que endereços inválidos sejam acessados?
Para evitar o acesso a endereços inválidos, os projetistas devem adotar boas práticas
como validação rigorosa de índices e ponteiros antes do acesso à memória, uso de
linguagens mais seguras como Rust ou Java, substituição de funções inseguras por
alternativas protegidas (inseguras como strcpy, gets e sprintf por alternativas seguras
(strncpy, fgets, snprintf), verificação de sucesso na alocação de memória antes de
acessá-la e ferramentas como AddressSanitizer (ASan) para detectar acessos
indevidos.
ii) Qual a importância de verificar limites antes de acessar a memória?
A verificação de limites antes do acesso à memória é essencial para impedir vazamento
de informações sigilosas (um acesso fora dos limites pode revelar dados sensíveis,
como chaves criptográficas ou credenciais armazenadas em áreas próximas na
memória), evitar corrupção de memória que pode comprometer a integridade do
sistema, mitigar ataques baseados em buffer overflow e garantir a estabilidade do
software. Sem essa verificação, ataques podem manipular os dados em áreas críticas
do programa, levando a falhas imprevisíveis e comprometimento da segurança
iii) Como a proteção no hardware pode prevenir a exploração de falhas?
Além das medidas no nível do software, o hardware também oferece proteções
essenciais contra exploração de falhas de memória. A unidade de gerenciamento de
memória (MMU) implementa segmentação epaginação para restringir acessos
indevidos entre processos. Recursos como Data Execution Prevention (DEP)
11
bloqueiam a execução de código em áreas de dados, prevenindo ataques por injeção
de código. O Address Space Layout Randomization (ASLR) randomiza a disposição da
memória, tornando mais difícil prever endereços de vulnerabilidades exploráveis.
Stack Canaries inserem valores na pilha para detectar sobregravação causada por
estouro de buffer, enquanto extensões como Memory Tagging Extension (MTE),
presentes em processadores ARM, identificam acessos inválidos por meio de tags de
memória. Dessa forma, a combinação de boas práticas no desenvolvimento de software
e os mecanismos de segurança fornecidos pelo hardware ajuda a minimizar
vulnerabilidades e proteger os sistemas contra ataques que exploram falhas de
memória.
Eis aqui as CWEs relevantes:
CWE-125: Out-of-bounds Read
https://cwe.mitre.org/data/definitions/125.html
→ A leitura fora dos limites pode permitir acesso não autorizado a áreas da
memória, possibilitando vazamento de dados sensíveis.
CWE-787: Out-of-bounds Write
https://cwe.mitre.org/data/definitions/787.html
→ Escritas em regiões não autorizadas da memória podem corromper dados,
comprometer a segurança do sistema e possibilitar execução arbitrária de código.