Perguntas entrevista segurança júnior

Introdução

Uma entrevista para engenheiro de segurança júnior costuma testar se você entende os fundamentos e consegue aplicá-los em situações reais: priorizar vulnerabilidades, ler alertas SIEM, proteger senhas, revisar TLS e responder a incidentes com calma.

Use estas perguntas para praticar respostas curtas que conectem o conceito à ação que você tomaria no trabalho.

Fundamentos de Segurança

1. Explique a Tríade CIA.

Resposta: A Tríade CIA é a base da segurança da informação:

Confidencialidade:

Apenas usuários autorizados podem acessar os dados
Alcançada através de: criptografia, controles de acesso, autenticação

Integridade:

Os dados permanecem precisos e não modificados
Alcançada através de: hashing, assinaturas digitais, checksums

Disponibilidade:

Sistemas e dados estão acessíveis quando necessário
Alcançada através de: redundância, backups, proteção contra DDoS

Loading diagram...

Exemplos de Violações:

Confidencialidade: Vazamento de dados expondo informações de clientes
Integridade: Atacante modificando registros financeiros
Disponibilidade: Ataque DDoS derrubando um website

Frequência: Muito Comum Dificuldade: Fácil

OWASP Top 10

2. Cite três itens do OWASP Top 10 e explique-os.

Resposta: OWASP Top 10 lista os riscos de segurança mais críticos para aplicações web:

1. Injeção (SQL Injection): Atacante insere código malicioso em consultas.

# Código vulnerável
username = request.GET['username']
query = f"SELECT * FROM users WHERE username = '{username}'"
# Ataque: username = "admin' OR '1'='1"

# Código seguro (consulta parametrizada)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))

2. Quebra de Controle de Acesso: Usuários podem acessar recursos que não deveriam.

# Vulnerável: Nenhuma verificação de autorização
@app.route('/admin/users/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)

# Seguro: Verificação de autorização
@app.route('/admin/users/<user_id>')
@require_admin
def get_user(user_id):
    if not current_user.is_admin:
        abort(403)
    return User.query.get(user_id)

3. Cross-Site Scripting (XSS): Atacante injeta scripts maliciosos em páginas web.

<!-- Vulnerável -->
<div>Bem-vindo, {{ username }}</div>

<!-- Ataque -->
username = "<script>alert('XSS')</script>"

<!-- Seguro (escape da saída) -->
<div>Bem-vindo, {{ username | escape }}</div>

Frequência: Muito Comum Dificuldade: Média

3. Como você realiza o gerenciamento de vulnerabilidades?

Resposta: O gerenciamento de vulnerabilidades é um processo contínuo de identificar, avaliar e remediar fraquezas de segurança. Uma boa resposta júnior menciona inventário de ativos, severidade, explorabilidade, exposição, impacto no negócio, responsável pela correção e verificação.

Não dependa apenas do CVSS. Priorize vulnerabilidades exploradas ativamente, expostas à internet, presentes em ativos críticos ou fáceis de encadear com outras falhas.

Processo:

Loading diagram...

Escaneamento de Vulnerabilidades:

# Escaneamento de vulnerabilidades com Nmap
nmap --script vuln 192.168.1.100

# Escaneamento com OpenVAS
openvas-start
# Acessar interface web em https://localhost:9392

# Escaneamento com Nessus (comercial)
# Configurar via interface web

Exemplo Nessus:

# Automatizar escaneamento com Nessus
import requests
import time

class NessusScanner:
    def __init__(self, url, access_key, secret_key):
        self.url = url
        self.headers = {
            'X-ApiKeys': f'accessKey={access_key}; secretKey={secret_key}'
        }
    
    def create_scan(self, name, targets):
        data = {
            'uuid': 'template-uuid',  # Escaneamento Básico de Rede
            'settings': {
                'name': name,
                'text_targets': targets
            }
        }
        response = requests.post(
            f'{self.url}/scans',
            headers=self.headers,
            json=data,
            verify=False
        )
        return response.json()['scan']['id']
    
    def launch_scan(self, scan_id):
        requests.post(
            f'{self.url}/scans/{scan_id}/launch',
            headers=self.headers,
            verify=False
        )
    
    def get_results(self, scan_id):
        response = requests.get(
            f'{self.url}/scans/{scan_id}',
            headers=self.headers,
            verify=False
        )
        return response.json()

# Uso
scanner = NessusScanner('https://nessus:8834', 'access_key', 'secret_key')
scan_id = scanner.create_scan('Escaneamento Semanal', '192.168.1.0/24')
scanner.launch_scan(scan_id)

Gerenciamento de Patch:

# Gerenciamento de patch no Linux
# Ubuntu/Debian
sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

# CentOS/RHEL
sudo yum check-update
sudo yum update -y

# Patch automatizado
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Matriz de Priorização:

Pontuação CVSS	Explorabilidade	Criticidade do Ativo	Prioridade
Crítico (9-10)	Exploit público	Produção	P1 (Imediato)
Alto (7-8.9)	PoC disponível	Produção	P2 (1 semana)
Médio (4-6.9)	Sem exploit	Interno	P3 (1 mês)
Baixo (0-3.9)	Sem exploit	Dev/Teste	P4 (Próximo ciclo)

Rastreamento de Remediação:

# Rastreamento de vulnerabilidades
class VulnerabilityTracker:
    def __init__(self):
        self.vulnerabilities = []
    
    def add_vulnerability(self, vuln):
        self.vulnerabilities.append({
            'id': vuln['id'],
            'severity': vuln['severity'],
            'asset': vuln['asset'],
            'status': 'open',
            'discovered': datetime.now(),
            'sla_deadline': self.calculate_sla(vuln['severity'])
        })
    
    def calculate_sla(self, severity):
        sla_days = {
            'critical': 7,
            'high': 30,
            'medium': 90,
            'low': 180
        }
        return datetime.now() + timedelta(days=sla_days[severity])
    
    def get_overdue(self):
        return [v for v in self.vulnerabilities 
                if v['status'] == 'open' and 
                datetime.now() > v['sla_deadline']]

Frequência: Comum Dificuldade: Fácil-Média

Noções Básicas de Criptografia

4. Qual é a diferença entre criptografia simétrica e assimétrica?

Resposta:

Criptografia Simétrica:

Mesma chave para criptografia e descriptografia
Rápida
Exemplos: AES, DES, 3DES

Criptografia Assimétrica:

Chave pública criptografa, chave privada descriptografa
Mais lenta
Exemplos: RSA, ECC

# Criptografia simétrica (AES)
from cryptography.fernet import Fernet

# Gerar chave
key = Fernet.generate_key()
cipher = Fernet(key)

# Criptografar
encrypted = cipher.encrypt(b"Mensagem secreta")

# Descriptografar
decrypted = cipher.decrypt(encrypted)

# Criptografia assimétrica (RSA)
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Gerar par de chaves
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Criptografar com chave pública, descriptografar com chave privada

Casos de Uso:

Simétrica: Criptografar grandes volumes de dados (arquivos, bancos de dados)
Assimétrica: Troca de chaves, assinaturas digitais, SSL/TLS

Frequência: Muito Comum Dificuldade: Fácil-Média

5. Como funciona o SSL/TLS e como você gerencia certificados?

Resposta: SSL/TLS criptografa dados em trânsito entre cliente e servidor.

Handshake TLS:

Loading diagram...

Como Funciona:

Client Hello: Cliente envia suites de cifras suportadas
Server Hello: Servidor escolhe a cifra, envia o certificado
Verificação do Certificado: Cliente valida a cadeia de certificados
Troca de Chave: Estabelece segredo compartilhado
Comunicação Criptografada: Usa criptografia simétrica

Componentes do Certificado:

# Visualizar detalhes do certificado
openssl x509 -in certificate.crt -text -noout

# O certificado contém:
# - Subject (nome do domínio)
# - Issuer (CA)
# - Período de validade
# - Chave pública
# - Assinatura

Gerenciamento de Certificados:

Gerar CSR (Certificate Signing Request):

# Gerar chave privada
openssl genrsa -out private.key 2048

# Gerar CSR
openssl req -new -key private.key -out request.csr

# Visualizar CSR
openssl req -text -noout -verify -in request.csr

Certificado Autoassinado (Teste):

# Gerar certificado autoassinado
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# Combinar para uso no servidor
cat cert.pem key.pem > server.pem

Instalar Certificado:

# Nginx
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

# Apache
<VirtualHost *:443>
    ServerName example.com
    
    SSLEngine on
    SSLCertificateFile /etc/apache2/ssl/cert.pem
    SSLCertificateKeyFile /etc/apache2/ssl/key.pem
    SSLCertificateChainFile /etc/apache2/ssl/chain.pem
    
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite HIGH:!aNULL:!MD5
</VirtualHost>

Configurações Incorretas Comuns:

1. Protocolos Fracos:

# Ruim: Permite SSLv3, TLSv1.0
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;

# Bom: Apenas TLS moderno
ssl_protocols TLSv1.2 TLSv1.3;

2. Cifras Fracas:

# Testar configuração SSL
sslscan example.com
nmap --script ssl-enum-ciphers -p 443 example.com

# Ou usar ferramentas online
# https://www.ssllabs.com/ssltest/

3. Certificados Expirados:

# Verificar expiração do certificado
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates

# Monitorar expiração
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | \
    openssl x509 -noout -enddate

Automação de Certificados (Let's Encrypt):

# Instalar certbot
sudo apt install certbot python3-certbot-nginx

# Obter certificado
sudo certbot --nginx -d example.com -d www.example.com

# Auto-renovação (cron)
0 0 * * * certbot renew --quiet

Solução de Problemas:

# Testar conexão TLS
openssl s_client -connect example.com:443 -servername example.com

# Verificar cadeia de certificados
openssl verify -CAfile ca-bundle.crt certificate.crt

# Verificar se o certificado corresponde à chave privada
openssl x509 -noout -modulus -in cert.pem | openssl md5
openssl rsa -noout -modulus -in key.pem | openssl md5
# Os hashes devem corresponder

Frequência: Comum Dificuldade: Média

Firewalls

6. Explique firewalls stateful vs stateless.

Resposta:

Firewall Stateless:

Examina cada pacote independentemente
Sem rastreamento de conexão
Mais rápido, mas menos seguro
Exemplo: Filtro de pacotes básico

Firewall Stateful:

Rastreia o estado da conexão
Lembra dos pacotes anteriores
Mais seguro
Exemplo: Firewalls modernos

# iptables (stateful)
# Permitir conexões estabelecidas
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Permitir novas conexões SSH
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# Descartar todo o resto
iptables -A INPUT -j DROP

Estados de Conexão:

NEW: Primeiro pacote da conexão
ESTABLISHED: Parte de uma conexão existente
RELATED: Relacionado a uma conexão existente
INVALID: Não corresponde a nenhum estado

Frequência: Comum Dificuldade: Média

SIEM

7. O que é um SIEM e por que é importante?

Resposta: SIEM (Security Information and Event Management) centraliza a coleta e análise de logs.

Funções Principais:

Coleta de Logs: Reunir logs de múltiplas fontes
Normalização: Padronizar formatos de log
Correlação: Identificar padrões e relacionamentos
Alertas: Notificar sobre atividade suspeita
Relatórios: Conformidade e forense

Loading diagram...

Casos de Uso:

Detectar ataques de força bruta
Identificar exfiltração de dados
Monitorar acesso privilegiado
Relatórios de conformidade (PCI-DSS, HIPAA)

Ferramentas SIEM Populares:

Splunk
ELK Stack (Elasticsearch, Logstash, Kibana)
IBM QRadar
ArcSight

Frequência: Comum Dificuldade: Média

8. Qual é a diferença entre IDS e IPS?

Resposta: IDS (Intrusion Detection System) e IPS (Intrusion Prevention System) monitoram o tráfego de rede em busca de ameaças.

Diferenças Chave:

Característica	IDS	IPS
Ação	Detecta e alerta	Detecta e bloqueia
Posicionamento	Fora de banda (passivo)	Inline (ativo)
Impacto	Sem interrupção do tráfego	Pode bloquear tráfego legítimo
Resposta	Manual	Automática
Falsos Positivos	Menos crítico	Mais crítico

Implantação de IDS:

Loading diagram...

Implantação de IPS:

Loading diagram...

Configuração do Snort (IDS/IPS):

# Instalar Snort
sudo apt install snort

# Configurar rede
sudo vi /etc/snort/snort.conf
# Definir HOME_NET
ipvar HOME_NET 192.168.1.0/24
ipvar EXTERNAL_NET !$HOME_NET

# Executar em modo IDS
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0

# Executar em modo IPS (inline)
sudo snort -Q -c /etc/snort/snort.conf -i eth0

Regras do Snort:

# Sintaxe da regra
# action protocol src_ip src_port -> dst_ip dst_port (options)

# Detectar injeção SQL
alert tcp any any -> $HOME_NET 80 (msg:"Tentativa de Injeção SQL"; \
    content:"UNION SELECT"; nocase; sid:1000001; rev:1;)

# Detectar port scan
alert tcp any any -> $HOME_NET any (msg:"Port Scan Detectado"; \
    flags:S; threshold:type both, track by_src, count 20, seconds 60; \
    sid:1000002; rev:1;)

# Detectar força bruta SSH
alert tcp any any -> $HOME_NET 22 (msg:"Força Bruta SSH"; \
    flags:S; threshold:type both, track by_src, count 5, seconds 60; \
    sid:1000003; rev:1;)

# Bloquear IP malicioso (modo IPS)
drop tcp 203.0.113.50 any -> $HOME_NET any (msg:"IP Malicioso Bloqueado"; \
    sid:1000004; rev:1;)

Suricata (Alternativa Moderna):

# Instalar Suricata
sudo apt install suricata

# Atualizar regras
sudo suricata-update

# Executar Suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# Visualizar alertas
sudo tail -f /var/log/suricata/fast.log

Análise de Alertas:

# Analisar alertas do Snort
import re
from collections import Counter

def analyze_snort_alerts(log_file):
    alerts = []
    
    with open(log_file, 'r') as f:
        for line in f:
            # Analisar alerta
            match = re.search(r'\[\*\*\] \[(\d+):(\d+):(\d+)\] (.+?) \[\*\*\]', line)
            if match:
                alerts.append({
                    'sid': match.group(1),
                    'message': match.group(4),
                    'line': line
                })
    
    # Principais alertas
    alert_counts = Counter([a['message'] for a in alerts])
    print("Top 10 Alertas:")
    for alert, count in alert_counts.most_common(10):
        print(f"{count:5d} - {alert}")
    
    return alerts

# Uso
alerts = analyze_snort_alerts('/var/log/snort/alert')

Assinaturas de Ataque Comuns:

# Injeção SQL
content:"' OR 1=1--";
content:"UNION SELECT";

# XSS
content:"<script>";
content:"javascript:";

# Injeção de Comando
content:";cat /etc/passwd";
content:"|whoami";

# Directory Traversal
content:"../../../";

# Shellshock
content:"() { :; };";

Melhores Práticas:

Atualizar assinaturas regularmente
Ajustar regras para reduzir falsos positivos
Monitorar IPS para tráfego legítimo bloqueado
Integrar com SIEM para correlação
Testar em modo IDS antes de habilitar o IPS

Frequência: Comum Dificuldade: Média

Melhores Práticas de Segurança

9. Como você protege senhas?

Resposta: Segurança de senha em várias camadas:

1. Hashing (não criptografia):

import hashlib
import os

def hash_password(password):
    # Gerar salt
    salt = os.urandom(32)
    
    # Hashear senha com salt
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # iterações
    )
    
    # Armazenar salt + hash
    return salt + key

def verify_password(stored_password, provided_password):
    salt = stored_password[:32]
    stored_key = stored_password[32:]
    
    key = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode('utf-8'),
        salt,
        100000
    )
    
    return key == stored_key

2. Política de Senhas:

Preferir senhas ou frases longas a regras rígidas de complexidade
Permitir gerenciadores de senha, colar e autofill
Bloquear senhas vazadas ou muito comuns
Exigir MFA quando possível
Forçar troca quando houver indício de comprometimento, não apenas por prazo fixo

3. Segurança Adicional:

Autenticação multifator (MFA)
Bloqueio de conta após tentativas falhas
Medidor de força da senha
Detecção de violação (API Have I Been Pwned)

Nunca:

Armazenar senhas em texto plano
Usar hashing fraco (MD5, SHA1)
Hashear sem salt

Frequência: Muito Comum Dificuldade: Média

Resposta a Incidentes

10. Quais são as fases da resposta a incidentes?

Resposta: Ciclo de Vida da Resposta a Incidentes do NIST:

1. Preparação:

Desenvolver plano IR
Treinar equipe
Configurar ferramentas e monitoramento

2. Detecção e Análise:

Identificar incidentes
Analisar escopo e impacto
Priorizar resposta

3. Contenção:

Curto prazo: Isolar sistemas afetados
Longo prazo: Aplicar patches, reconstruir sistemas

4. Erradicação:

Remover malware
Fechar vulnerabilidades
Fortalecer defesas

5. Recuperação:

Restaurar sistemas
Monitorar por reinfecção
Retornar às operações normais

6. Pós-Incidente:

Documentar lições aprendidas
Atualizar procedimentos
Melhorar defesas

Loading diagram...

Frequência: Comum Dificuldade: Média

Conclusão

Para uma entrevista de engenheiro de segurança júnior, prepare-se para explicar os fundamentos e mostrar como aplicaria cada um em um ambiente real. Foque em:

Fundamentos: Tríade CIA, menor privilégio, autenticação, autorização
OWASP: Controle de acesso quebrado, falhas criptográficas, injeção, logging e monitoramento
Gerenciamento de vulnerabilidades: Contexto do ativo, explorabilidade, correção, verificação
Criptografia e TLS: Criptografia, hashing, certificados, configurações modernas
Ferramentas defensivas: Firewalls, SIEM, IDS/IPS, ajuste de alertas
Segurança de senhas: Hashing, salts, MFA, checagem de senhas vazadas
Resposta a incidentes: Preparação, detecção, contenção, recuperação, lições aprendidas

Pratique com exemplos concretos de labs, projetos, estágios ou ambientes pessoais. Entrevistadores não esperam que você conheça todas as ferramentas; eles querem ver raciocínio claro, boa priorização e comunicação honesta.

Conselhos de carreira recentes

Perguntas de Entrevista para Engenheiro de Segurança Júnior

Introdução

Fundamentos de Segurança

1. Explique a Tríade CIA.

OWASP Top 10

2. Cite três itens do OWASP Top 10 e explique-os.

3. Como você realiza o gerenciamento de vulnerabilidades?

Noções Básicas de Criptografia

4. Qual é a diferença entre criptografia simétrica e assimétrica?

5. Como funciona o SSL/TLS e como você gerencia certificados?

Firewalls

6. Explique firewalls stateful vs stateless.

SIEM

7. O que é um SIEM e por que é importante?

8. Qual é a diferença entre IDS e IPS?

Melhores Práticas de Segurança

9. Como você protege senhas?

Resposta a Incidentes

10. Quais são as fases da resposta a incidentes?

Conclusão

Dicas de carreira semanais que realmente funcionam

Dicas de carreira semanais que realmente funcionam

Posts Relacionados

Perguntas de entrevista para engenheiro de redes júnior

Perguntas de entrevista para Junior SRE com respostas

Perguntas e respostas para administrador de sistemas júnior

Sua Próxima Entrevista Está a Apenas um Currículo de Distância

Compartilhar esta publicação

Faça Seus 6 Segundos Contarem