_passei direto_programação banco de dados

Prévia do material em texto

REVISAR ENVIO DO TESTE: CLIQUE AQUI PARA INICIAR O QUIZ 
 
Curso PROGRAMAÇÃO DE BANCO DE DADOS 
Status Completada 
Resultado da tentativa 10 em 10 pontos 
Resultados exibidos Todas as respostas, Respostas enviadas, Respostas corretas, Comentários 
• Pergunta 1 
1 em 1 pontos 
 
Considere a seguinte sequência de comandos: 
1. DELIMITER $$ 
2. CREATE PROCEDURE intervalo_aleatorio(IN tamanho int, OUT inicio int, OUT fim int) 
3. BEGIN 
4. SET inicio = ROUND(RAND()*100); 
5. SET fim = inicio + tamanho; 
6. END$$ 
7. DELIMITER ; 
8. CALL intervalo_aleatorio(10, @ini, @fim); 
9. SELECT @ini, @fim; 
Sobre a sequência de comandos, é correto afirmar: 
 
Resposta 
Selecionada: 
b. 
Todos os comandos serão executados com sucesso, e uma possível saída é: 
+------+------+ 
| @ini | @fim | 
+------+------+ 
| 46 | 56 | 
+------+------+ 
Respostas: a. 
A criação da procedure retornará um erro, pois a linha 4 deveria ser: 
 SELECT ROUND(RAND()*100) INTO inicio; 
 
b. 
Todos os comandos serão executados com sucesso, e uma possível saída é: 
+------+------+ 
| @ini | @fim | 
+------+------+ 
| 46 | 56 | 
+------+------+ 
 
c. 
O comando CALL retornará um erro, pois o nome do argumento (ini) não bate com o nome 
do parâmetro (inicio). 
 
d. 
O comando SELECT retornará um erro, pois os arrobas devem preceder os nomes das 
variáveis somente na chamada do procedimento (CALL). 
 
e. 
Todos os comandos serão executados com sucesso, e uma possível saída é: 
+--------+--------+ 
 
| @ini | @fim | 
+--------+--------+ 
| 0.46 | 0.56 | 
+--------+--------+ 
Comentário 
da resposta: 
A alternativa B é a correta, pois apresenta uma saída plausível para a execução dos 
comandos apresentados. O procedimento intervalo_aleatorio deve preencher a variável @ini 
com um valor entre 0 e 100, no caso foi 46. O procedimento intervalo_aleatorio deve 
preencher a variável @fim com o valor de @ini acrescido do valor do argumento tamanho. Ou 
seja, para @ini 46 e tamanho 10 (linha 8), @fim deve ser 46 + 10 = 56. 
O SELECT INTO somente é necessário quando se quer passar o resultado de um 
SELECT para uma variável. Não é o caso, por isso a alternativa A está errada. 
O nome do argumento não precisa bater com o nome do parâmetro. A 
correspondência é feita pela posição do argumento na lista de argumentos. Por isso, 
a alternativa C está errada. 
Os arrobas foram adequadamente utilizados na sequência de comandos. Por isso, a 
alternativa D está errada. 
A expressão ROUND(RAND()*100) retorna sempre um número inteiro entre 0 e 100, então não 
há como o valor de ini e fim serem fracionários. Por isso, a alternativa E está errada. 
 
• Pergunta 2 
1 em 1 pontos 
 
Considere a seguinte tabela usuario e sua tabela de auditoria usuario_auditoria: 
 
> describe usuario; 
+-------+------+------+-----+---------+----------------+ 
| Field | Type | Null | Key | Default | Extra | 
+-------+------+------+-----+---------+----------------+ 
| id | int | NO | PRI | NULL | auto_increment | 
| nome | text | YES | | NULL | | 
| papel | text | YES | | NULL | | 
+-------+------+------+-----+---------+----------------+ 
 
> describe usuario_auditoria; 
+----------------+----------+------+-----+---------+----------------+ 
| Field | Type | Null | Key | Default | Extra | 
+----------------+----------+------+-----+---------+----------------+ 
| id | int | NO | PRI | NULL | auto_increment | 
| data_hora_acao | datetime | YES | | NULL | | 
| usuario_acao | text | YES | | NULL | | 
| id_usuario | int | YES | | NULL | | 
| nome_antes | text | YES | | NULL | | 
| papel_antes | text | YES | | NULL | | 
| nome_depois | text | YES | | NULL | | 
| papel_depois | text | YES | | NULL | | 
+----------------+----------+------+-----+---------+----------------+ 
 
 
Considere as seguintes versões do gatilho responsável por inserir um registro de auditoria de inserção de 
usuário: 
 
CREATE TRIGGER audita_insercao_v1 BEFORE INSERT ON usuario FOR EACH ROW 
INSERT INTO usuario_auditoria (data_hora_acao, usuario_acao, id_usuario, nome_depois, papel_depois) 
VALUES 
 (NOW(), 
 CURRENT_USER(), 
 NEW.id, 
 NEW.nome, 
 NEW.papel); 
 
CREATE TRIGGER audita_insercao_v2 AFTER INSERT ON usuario FOR EACH ROW 
INSERT INTO usuario_auditoria (data_hora_acao, usuario_acao, id_usuario, nome_depois, papel_depois) 
VALUES 
 (NOW(), 
 CURRENT_USER(), 
 NEW.id, 
 NEW.nome, 
 NEW.papel); 
 
Assinale a alternativa correta. 
Resposta 
Selecionada: 
b. 
A versão 2 está correta, enquanto que a versão 1 possui um problema: pode não registrar o ID 
do usuário inserido. 
Respostas: a. 
A versão 2 está correta, enquanto que a versão 1 sempre deixará nulos os 
campos id_usuario, nome_depois e papel_depois. 
 
b. 
A versão 2 está correta, enquanto que a versão 1 possui um problema: pode não registrar o ID 
do usuário inserido. 
 c. 
Ambas as versões estão igualmente corretas. 
 d. 
Ambas as versões possuem erros de sintaxe. 
 e. 
Somente a versão 1 está correta. 
Comentário da 
resposta: 
A versão 1 possui tempo de ação BEFORE (antes), e antes da ação ainda não há um ID 
gerado para o registro (caso o ID não seja especificado no comando INSERT*). Por isso, a 
versão 1 pode não auditar o ID do registro inserido. 
 
Exemplo: insert into usuario (nome, papel) values ('joao', 'operario'); 
 
Já a versão 2 (AFTER) funciona corretamente. 
 
 
• Pergunta 3 
1 em 1 pontos 
 
Considere uma escola que possui as seguintes regras referentes à aprovação de alunos nas 
disciplinas: 
• Cada disciplina deve conter três provas. 
• As duas primeiras provas têm o mesmo peso na média final. 
• A terceira prova pesa o dobro da segunda (assim como o dobro da primeira) na média final. 
• Se a média final é menor que 5, o aluno está reprovado naquela disciplina. 
• Se a média final é pelo menos 5, o aluno está aprovado naquela disciplina. 
Nessa escola, as notas dos alunos são armazenadas em um banco de dados. A tabela notas, que 
armazena notas de alunos para diversas disciplinas, foi criada com o seguinte comando: 
CREATE TABLE notas(id_aluno int, id_disciplina int, p1 double, p2 double, p3 double); 
Assinale a alternativa que contém uma sequência válida de comandos que resulta na exibição de uma tabela 
com as colunas id_aluno, id_disciplina, media e situacao, sendo que a coluna media deve mostrar 
corretamente a média do aluno na disciplina de id id_disciplina e a coluna situacao deve mostrar se o aluno 
está “Aprovado” ou “Reprovado”. 
 
Resposta 
Selecionada: 
e. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNS double 
deterministic RETURN (p1 + p2 + 2*p3)/4; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) deterministic 
RETURN IF(media >= 5, 'Aprovado', 'Reprovado'); 
 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media(p1, p2, p3)) as 
situacao FROM notas; 
Respostas: a. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNS double 
deterministic RETURN (p1 + p2 + 2*p3)/4; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) deterministic RETURN 
CASE media 
 WHEN 0 THEN 'Reprovado' 
WHEN 1 THEN 'Reprovado' 
WHEN 2 THEN 'Reprovado' 
WHEN 3 THEN 'Reprovado' 
WHEN 4 THEN 'Reprovado' 
WHEN 5 THEN 'Aprovado' 
WHEN 6 THEN 'Aprovado' 
WHEN 7 THEN 'Aprovado' 
WHEN 8 THEN 'Aprovado' 
WHEN 9 THEN 'Aprovado' 
WHEN 10 THEN 'Aprovado' 
END; 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media(p1, p2, p3)) as 
situacao FROM notas; 
 
b. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNSdouble 
deterministic RETURN (p1 + p2 + 2*p3)/4; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) deterministic 
RETURN IF(media >= 5, 'Aprovado', 'Reprovado'); 
 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media) as situacao 
FROM notas; 
 
c. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNS double 
RETURN (p1 + p2 + 2*p3)/4; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) RETURN IF(media 
>= 5, 'Aprovado', 'Reprovado'); 
 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media(p1, p2, p3)) as 
situacao FROM notas; 
 
d. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNS double 
deterministic RETURN (p1 + p2 + p3)/3; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) deterministic 
RETURN IF(media >= 5, 'Aprovado', 'Reprovado'); 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media(p1, p2, p3)) as 
situacao FROM notas; 
 
e. 
CREATE FUNCTION media(p1 double, p2 double, p3 double) RETURNS double 
deterministic RETURN (p1 + p2 + 2*p3)/4; 
CREATE FUNCTION situacao(media float) RETURNS varchar(9) deterministic 
RETURN IF(media >= 5, 'Aprovado', 'Reprovado'); 
 
SELECT id_aluno, id_disciplina, media(p1, p2, p3) as media, situacao(media(p1, p2, p3)) as 
situacao FROM notas; 
Comentário da 
resposta: 
A alternativa E apresenta uma sequência de comandos que, com sucesso, cria uma função 
media, que retorna a média final do aluno seguindo os requisitos do enunciado em função 
das notas das provas; cria uma função situacao, que exibe a situação de aprovado ou 
reprovado em função da média; e faz uma seleção que, utilizando as funções criadas, lista a 
média e a situação de cada aluno em cada disciplina. 
A alternativa A está errada pois não funciona quando a média dá um valor não inteiro (por 
exemplo: 5,5). 
A alternativa B está errada pois a seleção “situacao(media)” é inválida. 
A alternativa C está errada pois as funções são criadas sem a característica 
deterministic. 
A alternativa D está errada pois a função media não considera corretamente a regra de 
ponderação entre as provas. 
 
• Pergunta 4 
1 em 1 pontos 
 
Considere a tabela produto criada com o seguinte comando: 
 
create table produto (id int auto_increment, descricao text, preco double, primary key (id)); 
 
Considere também a seguinte trigger associada à tabela produto: 
 
 
CREATE TRIGGER audita AFTER UPDATE ON produto FOR EACH ROW 
 INSERT INTO produto_auditoria (data_hora_alteracao, usuario_que_inseriu, id_produto) 
VALUES 
 (NOW(), CURRENT_USER(), OLD.id); 
 
Por fim, considere as seguintes sequências de comandos (obs.: uma sequência pode ter um só comando): 
 
I 
INSERT INTO produto (descricao, preco) VALUES ('Copo americano', 10); 
 
II 
DELETE FROM produto WHERE id = 1; 
 
III 
REPLACE INTO produto VALUES (100, 'Vaso chinês', 1000); 
REPLACE INTO produto VALUES (100, 'Vaso chinês', 2000); 
 
IV 
INSERT INTO produto VALUES (200, 'Cumbuca japonesa', 50) 
ON DUPLICATE KEY UPDATE descricao = 'Cumbuca japonesa', preco=50; 
INSERT INTO produto VALUES (200, 'Cumbuca japonesa', 70) 
ON DUPLICATE KEY UPDATE descricao = 'Cumbuca japonesa', preco=70; 
 
V 
UPDATE produto SET descricao = 'Cumbuca japonesa', preco=70 WHERE id = 200; 
 
Assinale a alternativa correta. 
Resposta Selecionada: b. 
As sequências IV e V disparam a trigger. 
Respostas: a. 
As sequências I, II, III, IV e V disparam a trigger. 
 b. 
As sequências IV e V disparam a trigger. 
 c. 
As sequências III, IV e V disparam a trigger. 
 d. 
Apenas a sequência V dispara a trigger. 
 e. 
Nenhuma das sequências dispara a trigger. 
Comentário da 
resposta: 
A trigger é disparada apenas pelo comando UPDATE, o que ocorre diretamente na sequência V 
e condicionalmente na sequência IV. A sequência III, apesar de efetuar uma atualização, não 
dispara a trigger por não realizar um UPDATE. Portanto, a alternativa “b” é a correta. 
 
 
• Pergunta 5 
1 em 1 pontos 
 
Considere as seguintes afirmações: 
 
I – A auditoria baseada em gatilhos pode fornecer informações mais detalhadas e customizadas sobre as 
manipulações dos registros do que os logs fornecidos pelo MySQL, contudo é bem mais trabalhosa de se 
implantar, pois, nesse caso, devemos programar diversos gatilhos. 
 
II – A auditoria baseada em gatilhos não possui grande valor, já que os gatilhos se aplicam somente aos 
comandos SQL disparados por um usuário diretamente conectado ao SGBD, e não pelos comandos 
disparados via aplicação. 
 
III – A auditoria baseada em gatilhos é uma medida preventiva e efetiva contra DBAs maliciosos. 
 
Assinale a alternativa que contém todas as afirmações verdadeiras. 
Resposta Selecionada: d. 
I. 
Respostas: a. 
I, II e III. 
 b. 
I e II. 
 c. 
II e III. 
 d. 
I. 
 e. 
III. 
Comentário da 
resposta: 
I – Verdadeira, pois, com a auditoria baseada em gatilhos, podemos determinar as 
informações que farão parte da auditoria, enquanto que nos logs do MySQL devemos 
aceitar a estrutura já fornecida. 
 
II – Falsa, pois os gatilhos também se aplicam aos comandos SQL vindos da aplicação. 
Afinal, tanto uma pessoa administradora quanto a aplicação acessam o SGBD utilizando 
um usuário do banco de dados. 
 
III – Falsa, pois o DBA, com plenos poderes administrativos sobre o SGBD, pode sempre remover 
os gatilhos que desejar. O cargo de DBA, com plenos poderes administrativos sobre o SGBD, é 
um cargo de extrema confiança. 
 
 
• Pergunta 6 
1 em 1 pontos 
 
Considere as seguintes sequências de comandos. 
Sequência 1: 
TRUNCATE pet; 
TRUNCATE dono; 
DROP procedure novo_pet_para_dono; 
 INSERT INTO dono(nome) VALUES ('nome_dono'); 
 
 DELIMITER $$ 
CREATE PROCEDURE novo_pet_para_dono(IN nome_dono text) 
BEGIN 
 DECLARE nome_pet text; 
 DECLARE id_dono int; 
 SET nome_pet = CONCAT('Pet ', ROUND(RAND()*100)); 
 SELECT id INTO id_dono FROM dono WHERE nome = nome_dono; 
 IF id_dono is not NULL THEN 
 INSERT INTO pet (nome, id_dono) VALUES (nome_pet, id_dono); 
 END IF; 
END$$ 
DELIMITER ; 
 SELECT COUNT(*) FROM pet; 
 
Sequência 2: 
TRUNCATE pet; 
TRUNCATE dono; 
DROP procedure novo_pet_para_dono; 
DELIMITER $$ 
CREATE PROCEDURE novo_pet_para_dono(IN nome_dono text) 
BEGIN 
 DECLARE nome_pet text; 
 DECLARE id_dono int; 
 SET nome_pet = CONCAT('Pet ', ROUND(RAND()*100)); 
 SELECT id INTO id_dono FROM dono WHERE nome = nome_dono; 
 IF id_dono is not NULL THEN 
 INSERT INTO pet (nome, id_dono) VALUES (nome_pet, id_dono); 
 END IF; 
END$$ 
DELIMITER ; 
 CALL novo_pet_para_dono('nome_dono'); 
 SELECT COUNT(*) FROM pet; 
 
Assinale a alternativa que apresenta corretamente a saída do último comando de cada sequência. 
Resposta Selecionada: e. 
 
Sequência 1 – 0. 
Sequência 2 – 0. 
Respostas: a. 
 
Sequência 1 – erro de sintaxe. 
Sequência 2 – 0. 
 
b. 
 
Sequência 1 – 1. 
Sequência 2 – 1. 
 
c. 
 
Sequência 1 – 0. 
Sequência 2 – 1. 
 
d. 
 
Sequência 1 – 1. 
Sequência 2 – 0. 
 
e. 
 
Sequência 1 – 0. 
Sequência 2 – 0. 
Comentário da 
resposta: 
Como o IF é avaliado somente quando da execução do procedimento, e não de sua 
declaração, a sequência 1 acaba não inserindo nenhum registro, pois nem sequer invoca o 
procedimento. 
Já a sequência 2 não insere nenhum registro, pois quando o procedimento é invocado não 
existe registro com nome “nome_dono” na tabela dono. 
 
 
• Pergunta 7 
1 em 1 pontos 
 
Funções de data e tempo: HOUR(tempo) 
Retorna a hora para tempo. O intervalo do valor de retorno é de 0 a 23 para valores de horas do dia. No 
entanto, o intervalo de valores TIME é, na verdade, muito maior, então HOUR pode retornar valores maiores 
do que 23. 
mysql> SELECT HOUR('10:05:03'); 
-> 10 
 
mysql> SELECT HOUR('272:59:59'); 
-> 272 
(Traduzidoda documentação oficial do MySQL. Disponível em: https://dev.mysql.com/doc/refman/8.0/en/date-and-time-
functions.html. Acesso em: 18 out. 2020.) 
 
Considere a seguinte tabela login: 
+------------+----------+------+-----+---------+-------+ 
| Field | Type | Null | Key | Default | Extra | 
+------------+----------+------+-----+---------+-------+ 
| data_hora | datetime | YES | | NULL | | 
| id_cliente | int | YES | | NULL | | 
+------------+----------+------+-----+---------+-------+ 
Considere agora o comando: 
SELECT HOUR(data_hora) as hora, count(*) FROM login GROUP BY hora; 
 Assinale a alternativa que melhor descreve uma possível intenção para a execução do comando acima. 
Resposta 
Selecionada: 
b. 
Investigar quais são os horários mais movimentados de uso do sistema. 
Respostas: a. 
Descobrir qual a última data-hora em que o sistema foi acessado. 
 b. 
Investigar quais são os horários mais movimentados de uso do sistema. 
 c. 
Descobrir o dia, e a hora desse dia, em que mais houve acessos ao sistema. 
 
d. 
Investigar quais são os horários mais movimentados de uso do sistema para um 
determinado dia. 
 e. 
Contar há quantas horas o sistema está funcionando. 
Comentário da 
resposta: 
O comando produz um resultado no formato: 
+------+----------+ 
| hora | count(*) | 
+------+----------+ 
| 12 | 3 | 
| 13 | 4 | 
| 14 | 1 | 
+------+----------+ 
 
Dessa forma, percebemos, ao longo de toda a vida do sistema, quantos logins (acessos) 
foram feitos em cada faixa de horário, sendo cada faixa uma das 24 horas do dia. Note que, 
no comando e na saída, não há nenhuma menção ao dia do login. 
 
• Pergunta 8 
1 em 1 pontos 
 
 
Considere a seguinte tabela login: 
 
+------------+----------+------+-----+---------+-------+ 
 
| Field | Type | Null | Key | Default | Extra | 
 
+------------+----------+------+-----+---------+-------+ 
 
| data_hora | datetime | YES | | NULL | | 
 
| id_cliente | int | YES | | NULL | | 
 
+------------+----------+------+-----+---------+-------+ 
 
 Considere agora o comando: 
 
 SELECT HOUR(data_hora) as hora, id_cliente FROM login GROUP BY hora; 
Qual o problema com o comando acima? 
 
Resposta 
Selecionada: 
c. 
A seleção da coluna id_cliente é incompatível com o agrupamento por hora, já que é um 
valor que varia dentro de um mesmo grupo. 
Respostas: a. 
Há um erro de sintaxe. 
 b. 
HOUR não pode ser usada com o GROUPY BY, pois não é uma função agregadora. 
 
c. 
A seleção da coluna id_cliente é incompatível com o agrupamento por hora, já que é um 
valor que varia dentro de um mesmo grupo. 
 
d. 
O alias hora não funciona no GROUP BY; seria preciso escrever GROUP BY 
HOUR(data_hora). 
 e. 
 
Não há nenhum problema com o comando. 
Comentário da 
resposta: 
 
Em uma seleção com agrupamento, os campos selecionados devem ou fazer parte da 
definição do agrupamento ou serem funções que agregam cada grupo. Não é o caso de 
seleção de id_cliente. O comando produz a seguinte saída: 
ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP BY clause and contains 
nonaggregated column 'brasil.login.id_cliente' which is not functionally dependent on 
columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by 
 
• Pergunta 9 
1 em 1 pontos 
 
Ataques de colisão SHA-1 agora são realmente práticos e criptografia se torna um perigo 
iminente 
 
O primeiro ataque de colisão de SHA-1 bem-sucedido no mundo real, conhecido como “SHAttered”, 
foi realizado em 2017. Acadêmicos da Google produziram dois arquivos que tinham o mesmo hash 
SHA-1. A pesquisa custou apenas U$ 110.000 para ser executada usando o poder de computação 
alugado pela nuvem, muito menos do que as pessoas achavam que poderia custar. 
 
Mas na semana passada, uma equipe de acadêmicos da França e Cingapura deram um passo 
adiante, demonstrando um ataque de colisão SHA-1 com “prefixo escolhido”: 
 
“Encontrar um ataque de colisão prático interrompe a função hash, mas o dano real que pode ser 
causado com essa colisão é um pouco limitado, já que o invasor terá pouco ou nenhum controle 
sobre os dados reais que colidem”, afirmou Thomas Peyrin, um dos pesquisadores do estudo. 
 
“Um ataque muito mais interessante é encontrar uma chamada ‘colisão de prefixo escolhido’, onde 
o invasor pode escolher livremente o prefixo para as duas mensagens as colidindo. Tais colisões 
mudam tudo em termos de ameaça porque agora você pode considerar ter colisões com dados 
significativos dentro (como nomes ou identidades em um certificado digital, etc.).” 
 
Os fornecedores de navegadores há muito tempo começaram a suspender o suporte para o tráfego 
TLS assinado pelo SHA-1 dentro de seus produtos; no entanto, outros aplicativos ainda contam 
com isso. 
 
Todos devem mudar para (em ordem de preferência): BLAKE2b / BLAKE2s, SHA-512/256, SHA3-
256, SHA-384 ou qualquer outra função hash da família SHA2 como último recurso. “Mas o SHA1 
não deve mais ser usado. Sem desculpas”, disse Arciszewski. 
 
(Fonte: SEGINFO. Ataques de colisão SHA-1 agora são realmente práticos e criptografia se torna um perigo 
iminente. SegInfo. 20 maio 2019. Disponível em: https://seginfo.com.br/2019/05/20/ataques-de-colisao-sha-1-agora-sao-realmente-
praticos-e-criptografia-se-torna-um-perigo-iminente/. Acesso em: 18 nov. 2020.) 
 
Assinale a alternativa que melhor explica e resume a notícia fornecida. 
 
Resposta 
Selecionada: 
a. 
Existem diversas funções de hash (resumos criptográficos). Uma propriedade importante de uma 
função hash é que deve ser muito difícil encontrar duas mensagens com o mesmo resumo (uma 
colisão). Os cientistas da Google encontraram duas mensagens com o mesmo resumo usando a 
função SHA-1 (encontraram uma colisão). Posteriormente, outros pesquisadores conseguiram 
outro tipo de colisão mais perigosa da SHA-1: eles escolheram parte das mensagens colididas. Por 
isso, a função SHA-1 deve ser evitada. 
Respostas: a. 
Existem diversas funções de hash (resumos criptográficos). Uma propriedade importante de uma 
função hash é que deve ser muito difícil encontrar duas mensagens com o mesmo resumo (uma 
colisão). Os cientistas da Google encontraram duas mensagens com o mesmo resumo usando a 
função SHA-1 (encontraram uma colisão). Posteriormente, outros pesquisadores conseguiram 
outro tipo de colisão mais perigosa da SHA-1: eles escolheram parte das mensagens colididas. Por 
isso, a função SHA-1 deve ser evitada. 
 
b. 
Existem diversas funções de hash (resumos criptográficos). Uma propriedade importante de uma 
função hash é que deve ser muito difícil encontrar duas mensagens com o mesmo resumo (uma 
colisão). Os cientistas da Google encontraram duas mensagens com o mesmo resumo usando a 
função SHA-1 (encontraram uma colisão). Posteriormente, outros pesquisadores conseguiram 
outro tipo de colisão mais perigosa da SHA-1: eles escolheram parte dos resumos colididos. Por 
isso, as funções de hash devem ser evitadas. 
 
c. 
Existem diversas funções de hash (resumos criptográficos). Uma propriedade importante de uma 
função hash é que ela deve ser cara de se computar (a Google, por exemplo, gastou U$ 110.000). 
Porém, posteriormente outros pesquisadores encontraram uma forma mais barata de se 
computar a função SHA-1, o que coloca em risco o sistema criptográfico. 
 
d. 
Existem diversas funções de hash (também chamadas de funções de colisão). Uma propriedade 
importante de uma função hash é que deve ser muito difícil encontrar os resumos de colisões 
distintas. Os cientistas da Google encontraram tais resumos para a função SHA-1. 
Posteriormente, outros pesquisadores conseguiram aprimorar a função SHA-1 de forma a limitar 
o real dano causado por esse tipo de ataque. 
 
e. 
Existem diversasfunções de hash (também chamadas de funções de colisão). Os cientistas da 
Google encontraram duas mensagens com o mesmo resumo usando a função SHA-1. 
Posteriormente, outros pesquisadores conseguiram outro tipo de colisão mais perigosa: eles 
escolheram parte das mensagens colididas. Por isso, as funções de hash devem ser evitadas. 
Comentário da 
resposta: 
A notícia mostra a evolução de ataques progressivamente mais perigosos contra a função de hash 
SHA-1. Funções de hash devem ser robustas a colisões, mas esses ataques mostram que a função 
SHA-1 não contempla de forma tão forte tal requisito. Por isso, os especialistas já recomendam a 
aposentadoria da função SHA-1, mas existem várias outras funções de hash que ainda podem ser 
usadas. 
 
• Pergunta 10 
1 em 1 pontos 
 
Considere as seguintes declarações: 
 
CREATE TRIGGER audita_insercao BEFORE INSERT ON produto FOR EACH ROW 
 
 INSERT INTO produto_auditoria (data_hora_alteracao, usuario, evento, id_produto) VALUES 
 (NOW(), CURRENT_USER(), 'INCLUSAO', NEW.id); 
 
CREATE TRIGGER audita_exclusao BEFORE DELETE ON produto FOR EACH ROW FOLLOWS 
audita_insercao 
 INSERT INTO produto_auditoria (data_hora_alteracao, usuario, evento, id_produto) VALUES 
 (NOW(), CURRENT_USER(), 'EXCLUSAO', OLD.id); 
 
Sobre a execução desses comandos, é correto dizer: 
Resposta Selecionada: e. 
A declaração de audita_exclusao resulta em erro. 
Respostas: a. 
Ambas as declarações funcionam, mas audita_exclusao nunca será disparada. 
 b. 
Ambas as declarações funcionam, mas audita_exclusao dará erro quando disparada. 
 c. 
Há um erro de sintaxe em audita_insercao. 
 d. 
As palavras NEW e OLD foram usadas indevidamente. 
 e. 
A declaração de audita_exclusao resulta em erro. 
Comentário 
da resposta: 
A palavra-chave FOLLOWS deve apontar para um gatilho que opere com a mesma tabela e 
comando (INSERT, UPDATE, DELETE) que o gatilho sendo declarado. Isso quer dizer 
que audita_exclusao não pode seguir (FOLLOWS) audita_insercao, pois são gatilhos de 
comandos diferentes (um é INSERT e o outro é DELETE). Assim, a alternativa correta é a “e”, 
pois a declaração de audita_exclusao produz o seguinte erro: 
ERROR 3011 (HY000): Referenced trigger 'audita_insercao' for the given action time and event 
type does not exist.